feature: Support typing.NewType in typeapi.ClassTypeHint (#38)

* feature: Support `typing.NewType` in `typeapi.ClassTypeHint`

* fix for older Python versions

* update comment

* insert pr into changelog

Author: NiklasRosenstein

.changelog/_unreleased.toml

@@ -0,0 +1,6 @@
+[[entries]]
+id = "a10b5733-3f9c-472f-a922-9f1fa33a3179"
+type = "feature"
+description = "Support `typing.NewType` in `typeapi.ClassTypeHint`"
+author = "@NiklasRosenstein"
+pr = "https://github.com/NiklasRosenstein/python-typeapi/pull/38"

src/typeapi/typehint.py

@@ -29,6 +29,7 @@
     get_type_hint_origin_or_none,
     get_type_hint_original_bases,
     get_type_hint_parameters,
+    is_new_type,
     type_repr,
 )
 
@@ -285,10 +286,11 @@ class ClassTypeHint(TypeHint):
 
     def __init__(self, hint: object, source: "Any | None" = None) -> None:
         super().__init__(hint, source)
-        assert isinstance(self.hint, type) or isinstance(self.origin, type), (
-            "ClassTypeHint must be initialized from a real type or a generic that points to a real type. "
-            f'Got "{self.hint!r}" with origin "{self.origin}"'
-        )
+        if not is_new_type(hint):
+            assert isinstance(self.hint, type) or isinstance(self.origin, type), (
+                "ClassTypeHint must be initialized from a real type or a generic that points to a real type. "
+                f'Got "{self.hint!r}" with origin "{self.origin}"'
+            )
 
     def parameterize(self, parameter_map: Mapping[object, Any]) -> "TypeHint":
         if self.type is Generic:  # type: ignore[comparison-overlap]
@@ -303,6 +305,8 @@ def type(self) -> type:
             return self.origin
         if isinstance(self.hint, type):
             return self.hint
+        if is_new_type(self.hint):
+            return self.hint.__supertype__
         assert False, "ClassTypeHint not initialized from a real type or a generic that points to a real type."
 
     @property

src/typeapi/typehint_test.py

@@ -1,4 +1,4 @@
-from typing import Any, ClassVar, Dict, Generic, List, Optional, Sequence, Tuple, TypeVar, Union
+from typing import Any, ClassVar, Dict, Generic, List, NewType, Optional, Sequence, Tuple, TypeVar, Union
 
 from pytest import mark
 from typing_extensions import Annotated, Literal, TypeAlias
@@ -263,6 +263,17 @@ def test__TypeHint__from_future_syntax_ForwardRef_union() -> None:
     assert hint.parameters == ()
 
 
+def test__TypeHint__from_newtype() -> None:
+    MyInt = NewType("MyInt", int)
+    hint = TypeHint(MyInt)
+    assert isinstance(hint, ClassTypeHint)
+    assert hint.args == ()
+    assert hint.bases == (object,)
+    assert hint.origin is None
+    assert hint.type is int
+    assert hint.hint is MyInt
+
+
 def test__ClassTypeHint__parametrize() -> None:
     """This method tests the infusion of type parameters into other types.
 

src/typeapi/utils.py

@@ -384,3 +384,18 @@ def is_typed_dict(hint: Any) -> TypeGuard[TypedDictProtocol]:
 
 class HasGetitem(Protocol, Generic[T_contra, U_co]):
     def __getitem__(self, __key: T_contra) -> U_co: ...
+
+
+class NewTypeP(Protocol):
+    """
+    Protocol for objects returned by `typing.NewType`.
+    """
+
+    __name__: str
+    __supertype__: type
+
+
+def is_new_type(hint: Any) -> TypeGuard[NewTypeP]:
+    # NOTE: Starting with Python 3.10, `typing.NewType` is actually a class instead of a function, but it is
+    #       still typed as a function in Mypy until 3.12.
+    return hasattr(hint, "__name__") and hasattr(hint, "__supertype__")