Support creating methods nicely in generated classes (#28)

To do this we convert our Callable+Param types into methods.  The main
reason for this is because it seems to be the expected thing, though
maybe we'd be better off keeping them as methods?

This lets us implement flatten_type fully in terms of
`NewProtocol`+`Members`, no special work needed, though!

I also added GenericCallable, since pulling that off required being
able to represent type params. I am suuuuper unsure about that one,
though.

Author: msullivan

pyproject.toml

@@ -56,6 +56,7 @@ extend-ignore = [
     "E402", # module-import-not-at-top-of-file
     "E252", # missing-whitespace-around-parameter-equals
     "F541", # f-string-missing-placeholders
+    "E731", # don't assign lambdas
 ]
 
 [tool.ruff.lint.per-file-ignores]

tests/test_schemalike.py

@@ -0,0 +1,79 @@
+import textwrap
+
+from typing import Callable, Literal
+
+from typemap.type_eval import eval_typing
+from typemap.typing import (
+    NewProtocol,
+    Iter,
+    Attrs,
+    GetType,
+    GetName,
+    Member,
+    Param,
+    StrConcat,
+)
+
+from . import format_helper
+
+
+class Schema:
+    pass
+
+
+class Type:
+    pass
+
+
+class Expression:
+    pass
+
+
+# hmmmm... recursion with this sort of thing will be funny...
+# how will we handle the decorators or __init_subclass__ or what have you
+
+
+class Property:
+    name: str
+    required: bool
+    multi: bool
+    typ: Type
+    expr: Expression | None
+
+
+type Schemaify[T] = NewProtocol[
+    *[p for p in Iter[Attrs[T]]],
+    *[
+        Member[
+            StrConcat[Literal["get_"], GetName[p]],
+            Callable[
+                [
+                    Param[Literal["self"], Schemaify[T]],
+                    Param[Literal["schema"], Schema, Literal["keyword"]],
+                ],
+                GetType[p],
+            ],
+            Literal["ClassVar"],
+        ]
+        for p in Iter[Attrs[T]]
+    ],
+]
+
+
+def test_schema_like_1():
+    tgt = eval_typing(Schemaify[Property])
+    fmt = format_helper.format_class(tgt)
+
+    assert fmt == textwrap.dedent("""\
+    class Schemaify[tests.test_schemalike.Property]:
+        name: str
+        required: bool
+        multi: bool
+        typ: tests.test_schemalike.Type
+        expr: tests.test_schemalike.Expression | None
+        def get_name(self: Schemaify[tests.test_schemalike.Property], *, schema: tests.test_schemalike.Schema) -> str: ...
+        def get_required(self: Schemaify[tests.test_schemalike.Property], *, schema: tests.test_schemalike.Schema) -> bool: ...
+        def get_multi(self: Schemaify[tests.test_schemalike.Property], *, schema: tests.test_schemalike.Schema) -> bool: ...
+        def get_typ(self: Schemaify[tests.test_schemalike.Property], *, schema: tests.test_schemalike.Schema) -> tests.test_schemalike.Type: ...
+        def get_expr(self: Schemaify[tests.test_schemalike.Property], *, schema: tests.test_schemalike.Schema) -> tests.test_schemalike.Expression | None: ...
+    """)

tests/test_type_dir.py

@@ -58,6 +58,12 @@ def sbase[Z](a: OrGotcha[T] | Z | None, b: K) -> dict[str, T | Z]:
         pass
 
 
+class CMethod:
+    @classmethod
+    def cbase2(cls, lol: int, /, a: bool | None) -> int:
+        pass
+
+
 class Wrapper[X](Base[X], AnotherBase[X]):
     x: "Wrapper[X | None]"
 
@@ -185,7 +191,7 @@ def test_type_dir_link_2():
     assert loop is Foo
 
 
-def test_type_dir_1():
+def test_type_dir_1a():
     d = eval_typing(Final)
 
     assert format_helper.format_class(d) == textwrap.dedent("""\
@@ -197,15 +203,25 @@ class Final:
             fin: typing.Final[int]
             x: tests.test_type_dir.Wrapper[int | None]
             ordinary: str
-            def foo(self, a: int | None, *, b: int = 0) -> dict[str, int]: ...
-            def base[Z](self, a: int | Z | None, b: ~K) -> dict[str, int | Z]: ...
+            def foo(self: tests.test_type_dir.Base[int], a: int | None, *, b: int = ...) -> dict[str, int]: ...
+            def base[Z](self: tests.test_type_dir.Base[int], a: int | Z | None, b: ~K) -> dict[str, int | Z]: ...
             @classmethod
-            def cbase(cls, a: int | None, b: ~K) -> dict[str, int]: ...
+            def cbase(cls: type[tests.test_type_dir.Base[int]], a: int | None, b: ~K) -> dict[str, int]: ...
             @staticmethod
             def sbase[Z](a: int | Literal['gotcha!'] | Z | None, b: ~K) -> dict[str, int | Z]: ...
     """)
 
 
+def test_type_dir_1b():
+    d = eval_typing(CMethod)
+
+    assert format_helper.format_class(d) == textwrap.dedent("""\
+        class CMethod:
+            @classmethod
+            def cbase2(_arg0: type[tests.test_type_dir.CMethod], _arg1: int, /, a: bool | None) -> int: ...
+    """)
+
+
 def test_type_dir_2():
     d = eval_typing(OptionalFinal)
 
@@ -394,6 +410,8 @@ def test_type_members_func_3():
 
     assert (
         str(typ)
+        #          == "\
+        # staticmethod[tuple[typemap.typing.Param[typing.Literal['a'], int | typing.Literal['gotcha!'] | Z | None, typing.Never], typemap.typing.Param[typing.Literal['b'], ~K, typing.Never]], dict[str, int | Z]]"
         == "\
-staticmethod[tuple[typemap.typing.Param[typing.Literal['a'], int | typing.Literal['gotcha!'] | Z | None, typing.Never], typemap.typing.Param[typing.Literal['b'], ~K, typing.Never]], dict[str, int | Z]]"
+typemap.typing.GenericCallable[tuple[Z], staticmethod[tuple[typemap.typing.Param[typing.Literal['a'], int | typing.Literal['gotcha!'] | Z | None, typing.Never], typemap.typing.Param[typing.Literal['b'], ~K, typing.Never]], dict[str, int | Z]]]"
     )

tests/test_type_eval.py

@@ -1,5 +1,3 @@
-import pytest
-
 import collections
 import textwrap
 import unittest
@@ -15,6 +13,8 @@
     Union,
 )
 
+import pytest
+
 from typemap.type_eval import eval_typing
 from typemap.typing import (
     Attrs,
@@ -730,3 +730,42 @@ def test_eval_literal_idempotent_01():
         nt = eval_typing(t)
         assert t == nt
         t = nt
+
+
+def test_callable_to_signature():
+    from typemap.type_eval._eval_operators import _callable_type_to_signature
+    from typemap.typing import Param
+
+    # Test the example from the docstring:
+    # def func(
+    #     a: int,
+    #     /,
+    #     b: int,
+    #     c: int = 0,
+    #     *args: int,
+    #     d: int,
+    #     e: int = 0,
+    #     **kwargs: int
+    # ) -> int:
+    callable_type = Callable[
+        [
+            Param[None, int],
+            Param[Literal["b"], int],
+            Param[Literal["c"], int, Literal["default"]],
+            Param[None, int, Literal["*"]],
+            Param[Literal["d"], int, Literal["keyword"]],
+            Param[Literal["e"], int, Literal["default", "keyword"]],
+            Param[None, int, Literal["**"]],
+        ],
+        int,
+    ]
+
+    sig = _callable_type_to_signature(callable_type)
+
+    params = list(sig.parameters.values())
+    assert len(params) == 7
+
+    assert str(sig) == (
+        '(_arg0: int, /, b: int, c: int = ..., *args: int, '
+        'd: int, e: int = ..., **kwargs: int) -> int'
+    )

typemap/type_eval/_apply_generic.py

@@ -396,4 +396,4 @@ def flatten_class_explicit(obj: typing.Any):
         return _flatten_class_explicit(obj, ctx)
 
 
-flatten_class = flatten_class_explicit
+flatten_class = flatten_class_new_proto