core: fix support for annotations defined with python3.12 'type' keyword

Author: karlicoss

src/cachew/__init__.py

@@ -14,6 +14,7 @@
     TYPE_CHECKING,
     Any,
     Literal,
+    TypeAliasType,
     cast,
     get_args,
     get_origin,
@@ -160,6 +161,16 @@ def infer_return_type(func) -> Failure | Inferred:
     >>> infer_return_type(union_provider)
     ('multiple', str | int)
 
+    >>> from typing import Iterator
+    >>> type Str = str
+    >>> type Int = int
+    >>> type IteratorStrInt = Iterator[Str | Int]
+    >>> def iterator_str_int() -> IteratorStrInt:
+    ...     yield 1
+    ...     yield 'aaa'
+    >>> infer_return_type(iterator_str_int)
+    ('multiple', Str | Int)
+
     # a bit of an edge case
     >>> from typing import Tuple
     >>> def empty_tuple() -> Iterator[Tuple[()]]:
@@ -197,6 +208,10 @@ def infer_return_type(func) -> Failure | Inferred:
     if rtype is None:
         return f"no return type annotation on {func}"
 
+    if isinstance(rtype, TypeAliasType):
+        # handle 'type ... = ...' aliases
+        rtype = rtype.__value__
+
     def bail(reason: str) -> str:
         return f"can't infer type from {rtype}: " + reason
 

src/cachew/marshall/cachew.py

@@ -14,6 +14,7 @@
     NamedTuple,
     Optional,
     Tuple,
+    TypeAliasType,
     Union,
     get_args,
     get_origin,
@@ -289,6 +290,10 @@ def load(self, dct: str):
 
 
 def build_schema(Type) -> Schema:
+    if isinstance(Type, TypeAliasType):
+        # handle 'type ... = ...' aliases
+        Type = Type.__value__
+
     # just to avoid confusion in case of weirdness with stringish type annotations
     assert not isinstance(Type, str), Type
 
@@ -414,6 +419,13 @@ def normalise(x):
     return (j, obj2)
 
 
+## this is used for test below...
+# however if we define this inside the test function, it fails if from __future__ import annotations is present on the file..
+type _IntType = int
+type _StrIntType = str | int
+##
+
+
 # TODO customise with cattrs
 def test_serialize_and_deserialize() -> None:
     import pytest
@@ -504,6 +516,22 @@ class WithJson:
         id: int
         raw_data: dict[str, Any]
 
+    ## type aliases including new 3.12 type aliases
+    # this works..
+    StrInt = str | int
+    helper('aaa', StrInt)
+
+    helper('aaa', _StrIntType)
+    helper([1, 2, 3], list[_IntType])
+
+    @dataclass
+    class TestTypeAlias:
+        x: _IntType
+        value: _StrIntType
+
+    helper(TestTypeAlias(x=1, value='aaa'), TestTypeAlias)
+    ##
+
     # json-ish stuff
     helper({}, dict[str, Any])
     helper(WithJson(id=123, raw_data={'payload': 'whatever', 'tags': ['a', 'b', 'c']}), WithJson)

src/cachew/tests/test_cachew.py

@@ -1439,3 +1439,25 @@ def fun_multiple() -> Iterable[int]:
 
     assert (tmp_path / callable_name(fun_single)).exists()
     assert (tmp_path / callable_name(fun_multiple)).exists()
+
+
+def test_type_alias_type_1(tmp_path: Path) -> None:
+    type Int = int
+
+    @cachew(tmp_path)
+    def fun() -> Iterator[Int]:
+        yield 123
+
+    assert list(fun()) == [123]
+    assert list(fun()) == [123]
+
+
+def test_type_alias_type_2(tmp_path: Path) -> None:
+    type IteratorInt = Iterator[int]
+
+    @cachew(tmp_path)
+    def fun() -> IteratorInt:
+        yield 123
+
+    assert list(fun()) == [123]
+    assert list(fun()) == [123]

src/cachew/tests/test_future_annotations.py

@@ -14,14 +14,16 @@
 
 from .. import cachew
 
+type _Str = str  # deliberate, to test 3.12 'type ... = ...' type definitions
+
 
 # fmt: off
 @dataclass
 class NewStyleTypes1:
     a_str   : str
     a_dict  : dict[str, Any]
     a_list  : list[Any]
-    a_tuple : tuple[float, str]
+    a_tuple : tuple[float, _Str]
 # fmt: on
 
 
@@ -45,7 +47,7 @@ def get() -> Iterator[NewStyleTypes1]:
 @dataclass
 class NewStyleTypes2:
     an_opt  : str | None
-    a_union : str | int
+    a_union : _Str | int
 # fmt: on
 
 
@@ -102,7 +104,7 @@ def test_future_annotations(
 '''
 
     _TEST = '''
-T = int
+type T = int
 
 @cachew(td)
 def fun() -> list[T]: