| Name | typenames JSON |
| Version |
1.3.0
JSON |
| download |
| home_page | None |
| Summary | String representations of type annotations. |
| upload_time | 2024-07-16 20:40:18 |
| maintainer | None |
| docs_url | None |
| author | None |
| requires_python | >=3.8 |
| license | MIT License Copyright (c) 2023 Jay Qi Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| keywords |
pep 585
pep 604
type annotations
type hints
typing
|
| VCS |
 |
| bugtrack_url |
|
| requirements |
No requirements were recorded.
|
| Travis-CI |
No Travis.
|
| coveralls test coverage |
No coveralls.
|
# typenames : String representations of type annotations
[](https://jayqi.github.io/typenames/)
[](https://pypi.org/project/typenames/)
[](https://pypi.org/project/typenames/)
[](https://github.com/jayqi/typenames/actions/workflows/tests.yml?query=branch%3Amain)
[](https://codecov.io/gh/jayqi/typenames)
**typenames** is a configurable Python library for creating string representations of type annotations. By default, it produces compact representations by removing standard library module names. Configurable options include standardizing on `|` operator syntax for unions or standard collections classes for generics.
```python
import typing
from typenames import typenames
typenames(int)
#> 'int'
typenames(dict[str, typing.Any])
#> 'dict[str, Any]'
typenames(str | int)
#> 'str | int'
typenames(typing.Optional[str])
#> 'Optional[str]'
```
## Why use this library?
String representations of Python type objects, type aliases, and special typing forms are inconsistent and often verbose. Here are some comparisons using default settings against built-in string representations:
| Input | With `str(...)` | With `typenames(...)` |
| :-: | :-: | :-: |
| `int` | `<class 'int'>` | `int` |
| `list` | `<class 'list'>` | `list` |
| `typing.Optional[int]` | `typing.Optional[int]` | `Optional[int]` |
| `collections.abc.Iterator[typing.Any]` | `collections.abc.Iterator[typing.Any]` | `Iterator[Any]` |
| `typing.Literal[MyEnum.NAME]` | `typing.Literal[<MyEnum.NAME: 'value'>]` | `Literal[MyEnum.NAME]` |
typenames also has handy configurable functionality, such as:
- Forcing standardization on `|` operator union syntax (e.g., `Union[int, str]` to `int | str`) or vice versa
- Forcing standardization on `|` operator optional syntax (e.g., `Optional[int]` to `int | None`) or vice versa
- Forcing standardization on standard collection types for generics (e.g., `List[int]` to `list[int]`) or vice versa
- Controlling exactly which module names to remove using regex patterns.
No need for string manipulation to get what you want!
## Installation
typenames is available on PyPI:
```bash
pip install typenames
```
## Basic Usage
The main way to use the library is the `typenames` function. Calling it on a type annotation renders a string representation:
```python
import typing
from typenames import typenames
typenames(int)
#> 'int'
typenames(typing.Optional[str])
#> 'Optional[str]'
typenames(collections.abc.Callable[[int], tuple[str, ...]])
#> 'Callable[[int], tuple[str, ...]]
```
Under the hood, typenames parses a type annotation as a tree structure. If you need to see the parsed tree, use the `parse_type_tree` function to return the root node. You can get the rendered string representation by calling `str(...)` on root node.
```python
import typing
from typenames import parse_type_tree
tree = parse_type_tree(typing.Union[typing.Any, list[typing.Any]])
tree
#> <GenericNode typing.Union[<TypeNode typing.Any>, <GenericNode <class 'list'>[<TypeNode typing.Any>]>]>
str(tree)
#> 'Union[Any, list[Any]]'
```
## Configurable options
All configuration options can be passed as keyword arguments to either the `typenames` or `parse_type_tree` functions.
### Union Syntax (`union_syntax`)
This option controls how unions are rendered. It supports both the `typing.Union` special form and the `|` operator (bitwise or) syntax from [PEP 604](https://peps.python.org/pep-0604/). Valid options are defined by the enum `UnionSyntax` and include:
- **`"as_given"` (default)**: render the union as it is given without changing syntax.
- **`"or_operator"`**: render all type unions using the `|` operator.
- **`"special_form"`**: render all type unions using the `typing.Union` special form.
Note that runtime use of the `|` operator between types is new in Python 3.10. To use in earlier versions of Python, you will need to use postponed evaluation of annotations à la [PEP 563](https://peps.python.org/pep-0563/) with `from __future__ import__annotations__`. Support for the `|` operator is only a limitation on providing type annotation inputs to typenames, and not a limitation on output rendering.
**Limitations:** Python automatically flattens unions when evaluating them at runtime. Since typenames uses runtime type objects, it will only see the flattened result and not know if your original input was nested. Furthermore, any mixing of `|` operator syntax and any typing module types will result in a `typing.Union` union, so `as_given` will always render such inputs with `typing.Union`.
### Optional Syntax (`optional_syntax`)
This option controls how optional types are rendered. It supports both the `typing.Optional` special form and the `|` operator (bitwise or) syntax from [PEP 604](https://peps.python.org/pep-0604/). Valid options are defined by the enum `OptionalSyntax` and include:
- **`"as_given"` (default)**: render the optional type as it is given without changing syntax
- **`"or_operator"`**: render all optional types using the `|` operator
- **`"union_special_form"`**: render all optional types using the `typing.Optional` special form
- **`"optional_special_form"`**: render all optional types using the `typing.Optional` special form
Note that runtime use of the `|` operator between types is new in Python 3.10. To use in earlier versions of Python, you will need to use postponed evaluation of annotations à la [PEP 563](https://peps.python.org/pep-0563/) with `from __future__ import__annotations__`. Support for the `|` operator is only a limitation on providing type annotation inputs to typenames, and not a limitation on output rendering.
**Limitations:**
- Python automatically converts `typing.Union[..., None]` to `typing.Optional[...]` when evaluating at runtime. Since typenames uses runtime type objects, it will only see the result using `typing.Optional` and not know the form of your original input.
- Python automatically flattens unions when evaluating them at runtime. Since typenames uses runtime type objects, it will only see the flattened result and not know if your original input was nested. Furthermore, any mixing of `|` operator syntax and any typing module types will result in a `typing.Union` union, so `as_given` will always render such inputs with typing module special forms.
- The `typing.Optional` special form only accepts exactly one parameter. By default, typenames will render cases with multiple parameters with `Optional[Union[...]]`. You can use the `union_syntax` option to control the inner union's syntax.
### Standard Collection Syntax (`standard_collection_syntax`)
This option controls how parameterized standard collection generic types are rendered. It supports both the typing module's generic aliases (e.g., `typing.List[...]`) and the standard class (e.g., `list[...]`) syntax from [PEP 585](https://peps.python.org/pep-0585/). Valid options are defined by the enum `StandardCollectionSyntax` and include:
- **`"as_given"` (default)**: render the parameterized generic type as it is given without changing syntax
- **`"standard_class"`**: render all parameterized standard collection generic types using their class
- **`"typing_module"`**: render all parameterized standard collection generic types using the typing module's generic alias
Note that runtime use of standard collection classes as parameterized generic types is new in Python 3.9. To use in earlier versions of Python, you will need to use postponed evaluation of annotations à la [PEP 563](https://peps.python.org/pep-0563/) with `from __future__ import__annotations__`. Support for standard collection classes for parameterized generic types is only a limitation on providing type annotation inputs to typenames, and not a limitation on output rendering.
### Removing Module Names (`remove_modules`)
This option controls how module names are removed from the rendered output. It takes a list of inputs, which can either be a string of the module name or a `re.Pattern` regex pattern directly (the result of `re.compile`). String inputs are templated into the following regex pattern:
```python
module: str # Given module name
re.compile(r"^{}\.".format(module.replace(".", r"\.")))
```
Note that module names are removed in the given order, so having entries that are submodules of other entries can potentially lead to the wrong behavior. You can either order them from higher-depth to lower-depth, or directly provide a compiled pattern with optional groups. For example, the pattern `re.compile(r"^collections\.(abc\.)?")` will match both `"collections."` and `"collections.abc."`.
The default list of module names include the standard library modules relevant to [PEP 585](https://peps.python.org/pep-0585/) plus `types` and `typing`. It can be accessed at `DEFAULT_REMOVE_MODULES`.
```python
DEFAULT_REMOVE_MODULES: List[Union[str, re.Pattern]] = [
"__main__",
"builtins",
re.compile(r"^collections\.(abc\.)?"),
"contextlib",
"re",
"types",
"typing",
]
```
If you are trying to _add_ additional modules to this option (rather than overriding the defaults), the easiest way to do so is to concatenate with the default list:
```python
from typing import Optional
from typenames import typenames, DEFAULT_REMOVE_MODULES, BaseNode
typenames(Optional[BaseNode])
#> 'Optional[typenames.BaseNode]'
typenames(Optional[BaseNode], remove_modules=["typenames"])
#> 'typing.Optional[BaseNode]'
typenames(
Optional[BaseNode],
remove_modules=DEFAULT_REMOVE_MODULES + ["typenames"],
)
#> 'Optional[BaseNode]'
```
To remove all module names, you can use `REMOVE_ALL_MODULES`, which contains the pattern `re.compile(r"^(<?\w+>?\.)+")`.
### Annotated (`include_extras`)
This option controls whether to render `typing.Annotated` (or `typing_extensions.Annotated` if using Python 3.8) and the extra metadata. `Annotated` is a [typing special form](https://docs.python.org/3/library/typing.html#typing.Annotated) introduced in Python 3.9 and originally specified by [PEP 593](https://peps.python.org/pep-0593/). Many libraries like [Pydantic](https://docs.pydantic.dev/latest/concepts/fields/#using-annotated), [FastAPI](https://fastapi.tiangolo.com/python-types/#type-hints-with-metadata-annotations), and [Typer](https://typer.tiangolo.com/tutorial/arguments/optional/#an-alternative-cli-argument-declaration) use it to attach metadata to type annotations that are used at runtime.
By default, typenames will _not_ render `Annotated` and extra metadata. Set `include_extras=True` to render them.
```python
from typing import Annotated
from typenames import typenames
typenames(Annotated[int, "some metadata"])
#> 'int'
typenames(Annotated[int, "some metadata"], include_extras=True)
#> "Annotated[int, 'some metadata']"
```
---
<sup>Reproducible examples created by <a href="https://github.com/jayqi/reprexlite">reprexlite</a>.</sup>
Raw data
{
"_id": null,
"home_page": null,
"name": "typenames",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.8",
"maintainer_email": null,
"keywords": "pep 585, pep 604, type annotations, type hints, typing",
"author": null,
"author_email": "Jay Qi <jayqi.opensource@gmail.com>",
"download_url": "https://files.pythonhosted.org/packages/50/39/4d9542b06191f7c5ab8cc9793f558fe7cd02efb10adaf13fbbc01a1a6489/typenames-1.3.0.tar.gz",
"platform": null,
"description": "# typenames : String representations of type annotations\n\n[](https://jayqi.github.io/typenames/)\n[](https://pypi.org/project/typenames/)\n[](https://pypi.org/project/typenames/)\n[](https://github.com/jayqi/typenames/actions/workflows/tests.yml?query=branch%3Amain)\n[](https://codecov.io/gh/jayqi/typenames)\n\n**typenames** is a configurable Python library for creating string representations of type annotations. By default, it produces compact representations by removing standard library module names. Configurable options include standardizing on `|` operator syntax for unions or standard collections classes for generics.\n\n```python\nimport typing\nfrom typenames import typenames\n\ntypenames(int)\n#> 'int'\ntypenames(dict[str, typing.Any])\n#> 'dict[str, Any]'\ntypenames(str | int)\n#> 'str | int'\ntypenames(typing.Optional[str])\n#> 'Optional[str]'\n```\n\n## Why use this library?\n\nString representations of Python type objects, type aliases, and special typing forms are inconsistent and often verbose. Here are some comparisons using default settings against built-in string representations:\n\n| Input | With `str(...)` | With `typenames(...)` |\n| :-: | :-: | :-: |\n| `int` | `<class 'int'>` | `int` |\n| `list` | `<class 'list'>` | `list` |\n| `typing.Optional[int]` | `typing.Optional[int]` | `Optional[int]` |\n| `collections.abc.Iterator[typing.Any]` | `collections.abc.Iterator[typing.Any]` | `Iterator[Any]` |\n| `typing.Literal[MyEnum.NAME]` | `typing.Literal[<MyEnum.NAME: 'value'>]` | `Literal[MyEnum.NAME]` |\n\ntypenames also has handy configurable functionality, such as:\n\n- Forcing standardization on `|` operator union syntax (e.g., `Union[int, str]` to `int | str`) or vice versa\n- Forcing standardization on `|` operator optional syntax (e.g., `Optional[int]` to `int | None`) or vice versa\n- Forcing standardization on standard collection types for generics (e.g., `List[int]` to `list[int]`) or vice versa\n- Controlling exactly which module names to remove using regex patterns.\n\nNo need for string manipulation to get what you want!\n\n## Installation\n\ntypenames is available on PyPI:\n\n```bash\npip install typenames\n```\n\n## Basic Usage\n\nThe main way to use the library is the `typenames` function. Calling it on a type annotation renders a string representation:\n\n```python\nimport typing\nfrom typenames import typenames\n\ntypenames(int)\n#> 'int'\ntypenames(typing.Optional[str])\n#> 'Optional[str]'\ntypenames(collections.abc.Callable[[int], tuple[str, ...]])\n#> 'Callable[[int], tuple[str, ...]]\n```\n\nUnder the hood, typenames parses a type annotation as a tree structure. If you need to see the parsed tree, use the `parse_type_tree` function to return the root node. You can get the rendered string representation by calling `str(...)` on root node.\n\n```python\nimport typing\nfrom typenames import parse_type_tree\n\ntree = parse_type_tree(typing.Union[typing.Any, list[typing.Any]])\ntree\n#> <GenericNode typing.Union[<TypeNode typing.Any>, <GenericNode <class 'list'>[<TypeNode typing.Any>]>]>\nstr(tree)\n#> 'Union[Any, list[Any]]'\n```\n\n## Configurable options\n\nAll configuration options can be passed as keyword arguments to either the `typenames` or `parse_type_tree` functions.\n\n### Union Syntax (`union_syntax`)\n\nThis option controls how unions are rendered. It supports both the `typing.Union` special form and the `|` operator (bitwise or) syntax from [PEP 604](https://peps.python.org/pep-0604/). Valid options are defined by the enum `UnionSyntax` and include:\n\n- **`\"as_given\"` (default)**: render the union as it is given without changing syntax.\n- **`\"or_operator\"`**: render all type unions using the `|` operator.\n- **`\"special_form\"`**: render all type unions using the `typing.Union` special form.\n\nNote that runtime use of the `|` operator between types is new in Python 3.10. To use in earlier versions of Python, you will need to use postponed evaluation of annotations \u00e0 la [PEP 563](https://peps.python.org/pep-0563/) with `from __future__ import__annotations__`. Support for the `|` operator is only a limitation on providing type annotation inputs to typenames, and not a limitation on output rendering.\n\n**Limitations:** Python automatically flattens unions when evaluating them at runtime. Since typenames uses runtime type objects, it will only see the flattened result and not know if your original input was nested. Furthermore, any mixing of `|` operator syntax and any typing module types will result in a `typing.Union` union, so `as_given` will always render such inputs with `typing.Union`.\n\n\n### Optional Syntax (`optional_syntax`)\n\nThis option controls how optional types are rendered. It supports both the `typing.Optional` special form and the `|` operator (bitwise or) syntax from [PEP 604](https://peps.python.org/pep-0604/). Valid options are defined by the enum `OptionalSyntax` and include:\n\n- **`\"as_given\"` (default)**: render the optional type as it is given without changing syntax\n- **`\"or_operator\"`**: render all optional types using the `|` operator\n- **`\"union_special_form\"`**: render all optional types using the `typing.Optional` special form\n- **`\"optional_special_form\"`**: render all optional types using the `typing.Optional` special form\n\nNote that runtime use of the `|` operator between types is new in Python 3.10. To use in earlier versions of Python, you will need to use postponed evaluation of annotations \u00e0 la [PEP 563](https://peps.python.org/pep-0563/) with `from __future__ import__annotations__`. Support for the `|` operator is only a limitation on providing type annotation inputs to typenames, and not a limitation on output rendering.\n\n**Limitations:**\n\n- Python automatically converts `typing.Union[..., None]` to `typing.Optional[...]` when evaluating at runtime. Since typenames uses runtime type objects, it will only see the result using `typing.Optional` and not know the form of your original input.\n- Python automatically flattens unions when evaluating them at runtime. Since typenames uses runtime type objects, it will only see the flattened result and not know if your original input was nested. Furthermore, any mixing of `|` operator syntax and any typing module types will result in a `typing.Union` union, so `as_given` will always render such inputs with typing module special forms.\n- The `typing.Optional` special form only accepts exactly one parameter. By default, typenames will render cases with multiple parameters with `Optional[Union[...]]`. You can use the `union_syntax` option to control the inner union's syntax.\n\n\n### Standard Collection Syntax (`standard_collection_syntax`)\n\nThis option controls how parameterized standard collection generic types are rendered. It supports both the typing module's generic aliases (e.g., `typing.List[...]`) and the standard class (e.g., `list[...]`) syntax from [PEP 585](https://peps.python.org/pep-0585/). Valid options are defined by the enum `StandardCollectionSyntax` and include:\n\n- **`\"as_given\"` (default)**: render the parameterized generic type as it is given without changing syntax\n- **`\"standard_class\"`**: render all parameterized standard collection generic types using their class\n- **`\"typing_module\"`**: render all parameterized standard collection generic types using the typing module's generic alias\n\nNote that runtime use of standard collection classes as parameterized generic types is new in Python 3.9. To use in earlier versions of Python, you will need to use postponed evaluation of annotations \u00e0 la [PEP 563](https://peps.python.org/pep-0563/) with `from __future__ import__annotations__`. Support for standard collection classes for parameterized generic types is only a limitation on providing type annotation inputs to typenames, and not a limitation on output rendering.\n\n### Removing Module Names (`remove_modules`)\n\nThis option controls how module names are removed from the rendered output. It takes a list of inputs, which can either be a string of the module name or a `re.Pattern` regex pattern directly (the result of `re.compile`). String inputs are templated into the following regex pattern:\n\n```python\nmodule: str # Given module name\nre.compile(r\"^{}\\.\".format(module.replace(\".\", r\"\\.\")))\n```\n\nNote that module names are removed in the given order, so having entries that are submodules of other entries can potentially lead to the wrong behavior. You can either order them from higher-depth to lower-depth, or directly provide a compiled pattern with optional groups. For example, the pattern `re.compile(r\"^collections\\.(abc\\.)?\")` will match both `\"collections.\"` and `\"collections.abc.\"`.\n\nThe default list of module names include the standard library modules relevant to [PEP 585](https://peps.python.org/pep-0585/) plus `types` and `typing`. It can be accessed at `DEFAULT_REMOVE_MODULES`.\n\n```python\nDEFAULT_REMOVE_MODULES: List[Union[str, re.Pattern]] = [\n \"__main__\",\n \"builtins\",\n re.compile(r\"^collections\\.(abc\\.)?\"),\n \"contextlib\",\n \"re\",\n \"types\",\n \"typing\",\n]\n```\n\nIf you are trying to _add_ additional modules to this option (rather than overriding the defaults), the easiest way to do so is to concatenate with the default list:\n\n```python\nfrom typing import Optional\nfrom typenames import typenames, DEFAULT_REMOVE_MODULES, BaseNode\n\ntypenames(Optional[BaseNode])\n#> 'Optional[typenames.BaseNode]'\ntypenames(Optional[BaseNode], remove_modules=[\"typenames\"])\n#> 'typing.Optional[BaseNode]'\ntypenames(\n Optional[BaseNode],\n remove_modules=DEFAULT_REMOVE_MODULES + [\"typenames\"],\n)\n#> 'Optional[BaseNode]'\n```\n\nTo remove all module names, you can use `REMOVE_ALL_MODULES`, which contains the pattern `re.compile(r\"^(<?\\w+>?\\.)+\")`.\n\n### Annotated (`include_extras`)\n\nThis option controls whether to render `typing.Annotated` (or `typing_extensions.Annotated` if using Python 3.8) and the extra metadata. `Annotated` is a [typing special form](https://docs.python.org/3/library/typing.html#typing.Annotated) introduced in Python 3.9 and originally specified by [PEP 593](https://peps.python.org/pep-0593/). Many libraries like [Pydantic](https://docs.pydantic.dev/latest/concepts/fields/#using-annotated), [FastAPI](https://fastapi.tiangolo.com/python-types/#type-hints-with-metadata-annotations), and [Typer](https://typer.tiangolo.com/tutorial/arguments/optional/#an-alternative-cli-argument-declaration) use it to attach metadata to type annotations that are used at runtime.\n\nBy default, typenames will _not_ render `Annotated` and extra metadata. Set `include_extras=True` to render them.\n\n```python\nfrom typing import Annotated\nfrom typenames import typenames\n\ntypenames(Annotated[int, \"some metadata\"])\n#> 'int'\ntypenames(Annotated[int, \"some metadata\"], include_extras=True)\n#> \"Annotated[int, 'some metadata']\"\n```\n\n---\n\n<sup>Reproducible examples created by <a href=\"https://github.com/jayqi/reprexlite\">reprexlite</a>.</sup>\n",
"bugtrack_url": null,
"license": "MIT License Copyright (c) 2023 Jay Qi Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.",
"summary": "String representations of type annotations.",
"version": "1.3.0",
"project_urls": {
"Bug Tracker": "https://github.com/jayqi/typenames/issues",
"Changelog": "https://jayqi.github.io/typenames/stable/changelog/",
"Documentation": "https://jayqi.github.io/typenames/",
"Homepage": "https://jayqi.github.io/typenames/",
"Repository": "https://github.com/jayqi/typenames"
},
"split_keywords": [
"pep 585",
" pep 604",
" type annotations",
" type hints",
" typing"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "8e04252cf801488cc05c355c5ddddb8a017be35b1f04b82a8ffcddbe59867218",
"md5": "cfb1a10396281a94b004e58b99a7d048",
"sha256": "666dfd7baebe3675dbdf950f19de08d5b15e5f9e0a71fe91fb8135ea68fe0889"
},
"downloads": -1,
"filename": "typenames-1.3.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "cfb1a10396281a94b004e58b99a7d048",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.8",
"size": 10528,
"upload_time": "2024-07-16T20:40:09",
"upload_time_iso_8601": "2024-07-16T20:40:09.532877Z",
"url": "https://files.pythonhosted.org/packages/8e/04/252cf801488cc05c355c5ddddb8a017be35b1f04b82a8ffcddbe59867218/typenames-1.3.0-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "50394d9542b06191f7c5ab8cc9793f558fe7cd02efb10adaf13fbbc01a1a6489",
"md5": "991121eb5383327cf458359c3dde754b",
"sha256": "205a1954512e28b6558e761c134e74d243003755676fe8cce49250b8fc192798"
},
"downloads": -1,
"filename": "typenames-1.3.0.tar.gz",
"has_sig": false,
"md5_digest": "991121eb5383327cf458359c3dde754b",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.8",
"size": 45717,
"upload_time": "2024-07-16T20:40:18",
"upload_time_iso_8601": "2024-07-16T20:40:18.331711Z",
"url": "https://files.pythonhosted.org/packages/50/39/4d9542b06191f7c5ab8cc9793f558fe7cd02efb10adaf13fbbc01a1a6489/typenames-1.3.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-07-16 20:40:18",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "jayqi",
"github_project": "typenames",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"lcname": "typenames"
}
