Add a bunch of typing tests

Author: msullivan

pyproject.toml

@@ -13,7 +13,7 @@ include = ["typemap", "typemap.*", "typemap_extensions"]
 test = [
     "pytest>=7.0",
     "ruff",
-    "mypy @ git+https://github.com/msullivan/mypy-typemap@f49083e5cd7124df93ea1a0a844d60adf901c250",
+    "mypy @ git+https://github.com/msullivan/mypy-typemap@9744d25fbd2a42ddb8b0cc6e5a74388e08c9ea7b",
 ]
 
 [tool.uv]

tests/test_dataclass_like.py

@@ -1,4 +1,5 @@
 from typing import (
+    assert_type,
     Callable,
     Literal,
     ReadOnly,
@@ -35,6 +36,15 @@ class Field[T: FieldArgs](typing.InitField[T]):
 )
 
 
+def _check_hero_init() -> None:
+    # required only
+    h = Hero(name='test', secret_name='secret')
+    assert_type(h, Hero)
+    # all keyword args
+    h2 = Hero(id=1, name='test', age=25, secret_name='secret')
+    assert_type(h2, Hero)
+
+
 # TODO: what could we do to make dataclass_ish work at runtime?
 
 

tests/test_fastapilike_2.py

@@ -1,5 +1,4 @@
-# SKIP MYPY: Invalid use of Self
-# TODO: resolve
+# TODO: resolve the invalid Self use issue that is type: ignored
 
 from typing import (
     Callable,
@@ -9,7 +8,6 @@
     TypedDict,
     Never,
     Self,
-    TYPE_CHECKING,
 )
 
 import typemap_extensions as typing
@@ -146,7 +144,7 @@ class Field[T: FieldArgs](typing.InitField[T]):
     Literal["__init__"],
     Callable[
         typing.Params[
-            typing.Param[Literal["self"], Self],
+            typing.Param[Literal["self"], Self],  # type: ignore[misc]
             *[
                 typing.Param[
                     p.name,
@@ -212,10 +210,44 @@ class Hero:
     secret_name: str = Field(hidden=True)
 
 
-# Quick reveal_type test for running mypy against this
-if TYPE_CHECKING:
-    pubhero: Public[Hero]
-    reveal_type(pubhero)  # noqa
+from typing import assert_type
+
+
+def _check_public(x: Public[Hero]) -> None:
+    # id becomes required int (primary_key strips | None), secret_name hidden
+    assert_type(
+        x,
+        typing.NewProtocol[
+            typing.Member[Literal["id"], int],
+            typing.Member[Literal["name"], str],
+            typing.Member[Literal["age"], int | None],
+        ],
+    )
+
+
+def _check_create(x: Create[Hero]) -> None:
+    # primary key excluded, rest preserved
+    assert_type(
+        x,
+        typing.NewProtocol[
+            typing.Member[Literal["name"], str],
+            typing.Member[Literal["age"], int | None],
+            typing.Member[Literal["secret_name"], str],
+        ],
+    )
+
+
+def _check_update(x: Update[Hero]) -> None:
+    # primary key excluded, all fields optional (| None)
+    assert_type(
+        x,
+        typing.NewProtocol[
+            typing.Member[Literal["name"], str | None],
+            typing.Member[Literal["age"], int | None],
+            typing.Member[Literal["secret_name"], str | None],
+        ],
+    )
+
 
 #######
 

tests/test_nplike.py

@@ -1,4 +1,4 @@
-from typing import Literal
+from typing import assert_type, Literal
 
 import typemap_extensions as typing
 
@@ -64,6 +64,21 @@ def __add__[*Shape2](
 
 type Apply[T, S] = Array[GetElem[T], *Broadcast[GetShape[T], GetShape[S]]]
 
+
+def _check_merge_one_broadcast(x: MergeOne[Literal[4], Literal[1]]) -> None:
+    assert_type(x, Literal[4])
+
+
+def _check_merge_one_equal(x: MergeOne[Literal[3], Literal[3]]) -> None:
+    assert_type(x, Literal[3])
+
+
+def _check_broadcast(
+    x: Broadcast[tuple[Literal[4], Literal[1]], tuple[Literal[3]]],
+) -> None:
+    assert_type(x, tuple[Literal[4], Literal[3]])
+
+
 ######
 from typemap.type_eval import eval_typing, TypeMapError
 

tests/test_qblike_2.py

@@ -1,6 +1,6 @@
 import textwrap
 
-from typing import Literal, Unpack, TYPE_CHECKING
+from typing import assert_type, Literal, Unpack
 
 from typemap.type_eval import eval_call, eval_typing
 import typemap_extensions as typing
@@ -152,16 +152,31 @@ class User:
     posts: MultiLink[Post]
 
 
-def test_qblike_typing_only_1() -> None:
-    # Quick reveal_type test for running mypy against this
-    if TYPE_CHECKING:
-        _test_select = select(
-            Post,
-            title=True,
-            comments=True,
-            author=True,
-        )
-        reveal_type(_test_select)  # noqa
+def _check_select_user() -> None:
+    r = select(User, id=True, name=True)
+    assert_type(
+        r,
+        list[
+            typing.NewProtocol[
+                typing.Member[Literal["id"], int],
+                typing.Member[Literal["name"], str],
+            ]
+        ],
+    )
+
+
+def _check_select_post_with_links() -> None:
+    r = select(Post, title=True, comments=True, author=True)
+    assert_type(
+        r,
+        list[
+            typing.NewProtocol[
+                typing.Member[Literal["title"], str],
+                typing.Member[Literal["comments"], list[PropsOnly[Comment]]],
+                typing.Member[Literal["author"], PropsOnly[User]],
+            ]
+        ],
+    )
 
 
 def test_qblike2_1():

tests/test_ts_utility.py

@@ -1,12 +1,19 @@
-# mypy: ignore-errors
 """
 TypeScript-style utility type operators: Pick, Omit, Partial.
 
 See https://www.typescriptlang.org/docs/handbook/utility-types.html
 """
 
 import textwrap
-from typing import Literal, Never, NotRequired, Required, TypedDict, Union
+from typing import (
+    assert_type,
+    Literal,
+    Never,
+    NotRequired,
+    Required,
+    TypedDict,
+    Union,
+)
 
 import typemap_extensions as typing
 from typemap.type_eval import eval_typing
@@ -105,6 +112,60 @@ class TodoTD(TypedDict):
 # End PEP section: Utility types
 
 
+def _check_exclude(x0: Exclude[str | int | bool, int]) -> None:
+    assert_type(x0, str)
+
+
+def _check_extract(x1: Extract[str | int | bool, int]) -> None:
+    assert_type(x1, int | bool)
+
+
+def _check_keyof(x2: KeyOf[Todo]) -> None:
+    assert_type(
+        x2, Literal["title"] | Literal["description"] | Literal["completed"]
+    )
+
+
+def _check_pick(
+    x3: Pick[Todo, Literal["title"] | Literal["completed"]],
+) -> None:
+    assert_type(x3.title, str)
+    assert_type(x3.completed, bool)
+    assert_type(
+        x3,
+        typing.NewProtocol[
+            typing.Member[Literal["title"], str],
+            typing.Member[Literal["completed"], bool],
+        ],
+    )
+
+
+def _check_omit(x4: Omit[Todo, Literal["description"]]) -> None:
+    assert_type(x4.title, str)
+    assert_type(x4.completed, bool)
+    assert_type(
+        x4,
+        typing.NewProtocol[
+            typing.Member[Literal["title"], str],
+            typing.Member[Literal["completed"], bool],
+        ],
+    )
+
+
+def _check_partial(x5: Partial[Todo]) -> None:
+    assert_type(x5.title, str | None)
+    assert_type(x5.description, str | None)
+    assert_type(x5.completed, bool | None)
+    assert_type(
+        x5,
+        typing.NewProtocol[
+            typing.Member[Literal["title"], str | None],
+            typing.Member[Literal["description"], str | None],
+            typing.Member[Literal["completed"], bool | None],
+        ],
+    )
+
+
 def test_pick():
     tgt = eval_typing(Pick[Todo, Literal["title"] | Literal["completed"]])
     fmt = format_helper.format_class(tgt)