Import from typing rather than use tp import alias

Author: delfick

README.rst

@@ -16,7 +16,7 @@ Example
 
 .. code-block:: python
 
-    import typing as tp
+    from typing import Annotated, NewType
 
     import attrs
 
@@ -25,8 +25,8 @@ Example
     reg = strcs.CreateRegister()
     creator = reg.make_decorator()
 
-    Number = tp.NewType("Number", int)
-    Word = tp.NewType("Word", str)
+    Number = NewType("Number", int)
+    Word = NewType("Word", str)
 
 
     @attrs.define(frozen=True)
@@ -43,9 +43,9 @@ Example
 
     @attrs.define
     class Config:
-        thing: tp.Annotated[Thing, strcs.FromMeta("thing")]
+        thing: Annotated[Thing, strcs.FromMeta("thing")]
         words: list[Word]
-        some_number: tp.Annotated[Number, Maths(multiply=2)]
+        some_number: Annotated[Number, Maths(multiply=2)]
         contrived1: str
         contrived2: str
         some_other_number: int = 16

docs/index.rst

@@ -65,7 +65,7 @@ Here is a contrived example that shows a couple features. Read the
     from my_library import Renderer 
 
     from attrs import define
-    import typing as tp
+    from typing import Annotated
     import strcs
 
 
@@ -82,7 +82,7 @@ Here is a contrived example that shows a couple features. Read the
 
         # Here we're using dependency injection to say get ``renderer`` from
         # the meta object we provide when creating objects.
-        renderer: tp.Annotated[Renderer, strcs.FromMeta("renderer")]
+        renderer: Annotated[Renderer, strcs.FromMeta("renderer")]
 
 
     @define

docs/strcs/features/annotations.rst

@@ -8,7 +8,7 @@ Annotations
 .. code-block:: python
 
     import attrs
-    import typing as tp
+    from typing import Annotated
     import strcs
 
     reg = strcs.CreateRegister()
@@ -27,14 +27,14 @@ Annotations
 
     @attrs.define
     class Thing:
-        val: tp.Annotated[int, strcs.Ann(MathsAnnotation(addition=20), do_maths)]
+        val: Annotated[int, strcs.Ann(MathsAnnotation(addition=20), do_maths)]
 
 
     @attrs.define
     class Holder:
         once: Thing
-        twice: tp.Annotated[Thing, MathsAnnotation(multiplication=2)]
-        thrice: tp.Annotated[Thing, MathsAnnotation(multiplication=3)]
+        twice: Annotated[Thing, MathsAnnotation(multiplication=2)]
+        thrice: Annotated[Thing, MathsAnnotation(multiplication=3)]
 
 
     @creator(Thing)

docs/strcs/features/creators.rst

@@ -45,7 +45,6 @@ this by returning a dictionary that cattrs will then use to create the instance.
 
 .. code-block:: python
 
-   import typing as tp
    import strcs
 
 
@@ -189,7 +188,7 @@ argument in the creator so that an infinite loop may be avoided.
 .. code-block:: python
 
     import attrs
-    import typing as tp
+    from typing import Annotated
     import secrets
     import strcs
 
@@ -201,7 +200,7 @@ argument in the creator so that an infinite loop may be avoided.
     @attrs.define
     class Part:
         one: int
-        identity: tp.Annotated[str, strcs.FromMeta("identity")]
+        identity: Annotated[str, strcs.FromMeta("identity")]
 
 
     @attrs.define
@@ -298,7 +297,7 @@ Generator creators may also yield other generators:
 .. code-block:: python
 
     import attrs
-    import typing as tp
+    from collections.abc import Generator
     import strcs
 
     reg = strcs.CreateRegister()
@@ -317,7 +316,7 @@ Generator creators may also yield other generators:
             self.three = None
 
 
-    def recursion_is_fun(value: object) -> tp.Generator[dict, Thing, None]:
+    def recursion_is_fun(value: object) -> Generator[dict, Thing, None]:
         assert isinstance(value, dict)
         assert value == {"one": 20}
         called.append(2)
@@ -327,7 +326,7 @@ Generator creators may also yield other generators:
 
 
     @creator(Thing)
-    def make(value: object) -> tp.Generator[tp.Generator[dict, Thing, None], Thing, None]:
+    def make(value: object) -> Generator[Generator[dict, Thing, None], Thing, None]:
         called.append(1)
         made = yield recursion_is_fun(value)
         made.three = 222

strcs/annotations.py

@@ -19,7 +19,7 @@
 object as a creator override.
 """
 
-import typing as tp
+from typing import TYPE_CHECKING, Generic, Protocol, TypeVar, cast, runtime_checkable
 
 import attrs
 
@@ -32,14 +32,14 @@
 from .disassemble import Type, TypeCache
 from .meta import Meta
 
-if tp.TYPE_CHECKING:
+if TYPE_CHECKING:
     from .register import CreateRegister
 
-T = tp.TypeVar("T")
+T = TypeVar("T")
 
 
-@tp.runtime_checkable
-class AdjustableMeta(tp.Protocol[T]):
+@runtime_checkable
+class AdjustableMeta(Protocol[T]):
     """
     An interface used to modify the meta object when creating a field.
 
@@ -55,8 +55,8 @@ class AdjustableMeta(tp.Protocol[T]):
     def adjusted_meta(self, meta: Meta, typ: Type[T], type_cache: TypeCache) -> Meta: ...
 
 
-@tp.runtime_checkable
-class AdjustableCreator(tp.Protocol[T]):
+@runtime_checkable
+class AdjustableCreator(Protocol[T]):
     """
     An interface used to modify the creator used when creating a field.
 
@@ -105,7 +105,7 @@ class MetaAnnotation:
     .. code-block:: python
 
         import attrs
-        import typing as tp
+        from typing import Annotated
         import strcs
 
         reg = strcs.CreateRegister()
@@ -120,7 +120,7 @@ class MyAnnotation(strcs.MetaAnnotation):
 
         @attrs.define
         class MyKls:
-            key: tp.Annotated[str, MyAnnotation(one=1, two=2)]
+            key: Annotated[str, MyAnnotation(one=1, two=2)]
 
 
         @creator(MyKls)
@@ -147,7 +147,7 @@ class MergedMetaAnnotation:
     .. code-block:: python
 
         import attrs
-        import typing as tp
+        from typing import Annotated
         import strcs
 
         reg = strcs.CreateRegister()
@@ -162,7 +162,7 @@ class MyAnnotation(strcs.MergedMetaAnnotation):
 
         @attrs.define
         class MyKls:
-            key: tp.Annotated[str, MyAnnotation(one=1, two=2)]
+            key: Annotated[str, MyAnnotation(one=1, two=2)]
 
 
 
@@ -193,7 +193,7 @@ def create_mykls(value: object, /, one: int = 0, two: int = 0) -> dict | None:
     """
 
 
-class Ann(tp.Generic[T]):
+class Ann(Generic[T]):
     """
     A concrete implementation of both ``strcs.AdjustedMeta`` and
     ``strcs.AdjustedCreator``.
@@ -270,7 +270,7 @@ class FromMeta:
     .. code-block:: python
 
         import attrs
-        import typing as tp
+        from typing import Annotated
         import strcs
 
         reg = strcs.CreateRegister()
@@ -284,7 +284,7 @@ def incantation(self) -> str:
 
         @attrs.define
         class Wizard:
-            magic: tp.Annotated[Magic, strcs.FromMeta("magic")]
+            magic: Annotated[Magic, strcs.FromMeta("magic")]
 
 
         wizard = reg.create(Wizard, meta=reg.meta({"magic": Magic()}))
@@ -305,7 +305,7 @@ def adjusted_creator(
         type_cache: TypeCache,
     ) -> ConvertFunction[T] | None:
         def retrieve(value: object, /, _meta: Meta) -> ConvertResponse[T]:
-            return tp.cast(T, _meta.retrieve_one(object, "retrieved", type_cache=type_cache))
+            return cast(T, _meta.retrieve_one(object, "retrieved", type_cache=type_cache))
 
         a = Ann[T](creator=retrieve)
         return a.adjusted_creator(creator, register, typ, type_cache)

strcs/args_extractor.py

@@ -10,21 +10,21 @@
 """
 
 import inspect
-import typing as tp
+from typing import TYPE_CHECKING, Generic, TypeVar
 
 import cattrs
 
 from .disassemble import Type
 from .meta import Meta
 
-if tp.TYPE_CHECKING:
+if TYPE_CHECKING:
     from .decorator import ConvertDefinition
     from .register import CreateRegister
 
-T = tp.TypeVar("T")
+T = TypeVar("T")
 
 
-class ArgsExtractor(tp.Generic[T]):
+class ArgsExtractor(Generic[T]):
     def __init__(
         self,
         *,

strcs/decorator.py

@@ -71,8 +71,8 @@ def create_thing(value: object, /) -> strcs.ConvertResponse[Thing]:
 """
 
 import inspect
-import typing as tp
-from collections.abc import Mapping
+from collections.abc import Callable, Generator, Mapping
+from typing import TYPE_CHECKING, Generic, TypeVar, cast
 
 import attrs
 import cattrs
@@ -84,14 +84,14 @@ def create_thing(value: object, /) -> strcs.ConvertResponse[Thing]:
 from .not_specified import NotSpecified, NotSpecifiedMeta
 from .standard import builtin_types
 
-if tp.TYPE_CHECKING:
+if TYPE_CHECKING:
     from .register import CreateRegister
 
-T = tp.TypeVar("T")
+T = TypeVar("T")
 
 
 @attrs.define
-class CreateArgs(tp.Generic[T]):
+class CreateArgs(Generic[T]):
     """
     The object given to ``ConvertFunction`` objects to produce an instance of the
     desired type.
@@ -108,7 +108,7 @@ class CreateArgs(tp.Generic[T]):
 # Either a value instructing strcs to do something, an object that strcs should
 # use as is, or a generator that can operate on the object strcs creates.
 type ConvertResponseValues[T] = bool | dict[str, object] | T | NotSpecifiedMeta
-type ConvertResponseGenerator[T] = tp.Generator[ConvertResponseValues[T] | tp.Generator | None, T]
+type ConvertResponseGenerator[T] = Generator[ConvertResponseValues[T] | Generator | None, T]
 type ConvertResponse[T] = ConvertResponseValues[T] | ConvertResponseGenerator[T] | None
 
 # ConvertDefinition is the developer provided functions that do transformation
@@ -124,11 +124,11 @@ class CreateArgs(tp.Generic[T]):
 # - want: Type[T] = The strcs.Type object for the desired type
 # - meta values are from the meta object, or the special objects known by
 #   strcs.ArgExtractor
-type ConvertDefinition[T] = tp.Callable[..., ConvertResponse[T]]
+type ConvertDefinition[T] = Callable[..., ConvertResponse[T]]
 
 # ConvertFunction is the object the strcs.CreateRegister interacts with to invoke
 # the ConvertDefinition objects.
-type ConvertFunction[T] = tp.Callable[[CreateArgs[T]], T]
+type ConvertFunction[T] = Callable[[CreateArgs[T]], T]
 
 
 def take_or_make(value: object, want: Type[T], /) -> ConvertResponse[T]:
@@ -148,7 +148,7 @@ def take_or_make(value: object, want: Type[T], /) -> ConvertResponse[T]:
         return None
 
 
-class WrappedCreator(tp.Generic[T]):
+class WrappedCreator(Generic[T]):
     """
     An implementation of ``strcs.ConvertFunction`` that operates on the provided
     ConvertDefinition.
@@ -197,7 +197,7 @@ def __call__(self, create_args: "CreateArgs") -> T:
 
         if self.assume_unchanged_converted and want.is_type_for(value):
             if want.origin_type not in builtin_types:
-                return tp.cast(T, value)
+                return cast(T, value)
 
         try:
             args = ArgsExtractor(
@@ -260,7 +260,7 @@ def deal(res: ConvertResponse[T], value: object) -> T:
                         reason="Told to use NotSpecified as the final value",
                         creator=self.func,
                     )
-                return tp.cast(T, value)
+                return cast(T, value)
             else:
                 if not isinstance(res, Mapping) and issubclass(
                     want.checkable, self.type_cache.disassemble(type(res)).checkable
@@ -288,7 +288,7 @@ def _process_generator(
         self,
         res: ConvertResponseGenerator[T],
         value: object,
-        deal: tp.Callable[[ConvertResponse[T], object], T],
+        deal: Callable[[ConvertResponse[T], object], T],
     ) -> T:
         try:
             made: ConvertResponse[T]