modern_types

__modern_types__ aims to provide PEP 585 + PEP 604 backports for Python <=3.10 deferred type evaluation backward compatibility. Hence, the targeted Python versions are 3.8 and 3.9.

What does it do?

Prevents type errors in evaluating PEP 585 and PEP 604 type annotations for Python 3.8 and 3.9, which might happen in pydantic models for example.

from __future__ import annotations
from collections import defaultdict
from pprint import pprint
from typing import get_type_hints

import __modern_types__

class Foo:
    a: dict[str, int]
    b: list[int]
    c: set[int]
    d: tuple[int, ...] | None
    e: frozenset[int]
    f: defaultdict[str, int]

pprint(get_type_hints(Foo, globals(), locals()))

gives:

{"a": typing.Dict[str, int],
 "b": typing.List[int],
 "c": typing.Set[int],
 "d": typing.Union[typing.Tuple[int, ...], None],
 "e": typing.FrozenSet[int],
 "f": typing.DefaultDict[str, int]}

How to use?

Simply import __modern_types__ in your code, and it will override the default global namespace of typing.get_type_hints.

And now you can use modern types everywhere in your code and the following replacements will be applied without overwriting your parameters:

[!Note] Some optional replacements will also be performed if possible, according to those listed in the __modern_types__.ext source code.

__modern_types__ additionally makes sure that generic aliases above are instantiable, which isn't the default behavior.

Use case

Keep your codebase up-to-date by speeding up migrating to modern types, even if you support Python versions >=3.8,<=3.10. Stop using deprecated typing.Dict, typing.List, typing.Set, typing.Tuple, typing.FrozenSet and typing.DefaultDict! Importing __modern_types__ will make all typing.get_type_hints-dependent parts of your application, including pydantic models, work with PEP 585 and PEP 604.

Can __modern_types__ be used in production?

Yes. It won't break the existing code despite the monkeypatch. The library simply overrides the default global namespace of typing.get_type_hints and tries to re-assign name-to-object references of un-subscriptable and un-orable types in relevant modules. If some keys that __modern_types__ would supply to typing.get_type_hints global namespace are present, they are used instead of the __modern_types__ ones.

Installation

If you want to…

…use this tool in your project 💻

You might simply install it with pip:

pip install modern-types

If you use Poetry, then run:

poetry add modern-types

…contribute to modern_types 🚀

[!Note] If you use Windows, it is highly recommended to complete the installation in the way presented below through WSL2.

1. Fork the modern_types repository on GitHub.

2. Install Poetry.
   Poetry is an amazing tool for managing dependencies & virtual environments, building packages and publishing them. You might use pipx to install it globally (recommended):

   pipx install poetry
   

   _{If you encounter any problems, refer to the official documentation for the most up-to-date installation instructions.}

   Be sure to have Python 3.8 installed—if you use pyenv, simply run:

   pyenv install 3.8
   

3. Clone your fork locally and install dependencies.

   git clone https://github.com/your-username/modern_types path/to/modern_types
   cd path/to/modern_types
   poetry env use $(cat .python-version)
   poetry install
   

   Next up, simply activate the virtual environment and install pre-commit hooks:

   poetry shell
   pre-commit install --hook-type pre-commit --hook-type pre-push
   

For more information on how to contribute, check out CONTRIBUTING.md.
Always happy to accept contributions! ❤️

Legal info

© Copyright by Bartosz Sławecki (@bswck).
This software is licensed under the terms of MIT License.