ducktools-classbuilder 0.10.0__tar.gz → 0.10.2__tar.gz

{ducktools_classbuilder-0.10.0 → ducktools_classbuilder-0.10.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ducktools-classbuilder
-Version: 0.10.0
+Version: 0.10.2
 Summary: Toolkit for creating class boilerplate generators
 Author: David C Ellis
 Project-URL: Homepage, https://github.com/davidcellis/ducktools-classbuilder

{ducktools_classbuilder-0.10.0 → ducktools_classbuilder-0.10.2}/pyproject.toml

@@ -28,8 +28,8 @@ dynamic = ['version']
 [project.optional-dependencies]
 # Needed for the current readthedocs.yaml
 docs = [
-    "sphinx>=8.1", 
-    "myst-parser>=4.0", 
+    "sphinx>=8.1",
+    "myst-parser>=4.0",
     "sphinx_rtd_theme>=3.0",
 ]
 
@@ -38,6 +38,7 @@ dev = [
     "pytest>=8.4",
     "pytest-cov>=6.1",
     "mypy>=1.16",
+    "typing-extensions>=4.14",
 ]
 performance = [
     "attrs>=25.0",

{ducktools_classbuilder-0.10.0 → ducktools_classbuilder-0.10.2}/src/ducktools/classbuilder/__init__.py

@@ -31,8 +31,9 @@
 # Field itself sidesteps this by defining __slots__ to avoid that branch.
 
 import os
+import sys
 
-from .annotations import get_ns_annotations, is_classvar
+from .annotations import get_ns_annotations, is_classvar, make_annotate_func
 from ._version import __version__, __version_tuple__  # noqa: F401
 
 # Change this name if you make heavy modifications
@@ -131,19 +132,25 @@ class GeneratedCode:
     This class provides a return value for the generated output from source code
     generators.
     """
-    __slots__ = ("source_code", "globs")
+    __slots__ = ("source_code", "globs", "annotations")
 
-    def __init__(self, source_code, globs):
+    def __init__(self, source_code, globs, annotations=None):
         self.source_code = source_code
         self.globs = globs
+        self.annotations = annotations
 
     def __repr__(self):
         first_source_line = self.source_code.split("\n")[0]
-        return f"GeneratorOutput(source_code='{first_source_line} ...', globs={self.globs!r})"
+        return (
+            f"GeneratorOutput(source_code='{first_source_line} ...', "
+            f"globs={self.globs!r}, annotations={self.annotations!r})"
+        )
 
     def __eq__(self, other):
         if self.__class__ is other.__class__:
-            return (self.source_code, self.globs) == (other.source_code, other.globs)
+            return (self.source_code, self.globs, self.annotations) == (
+                other.source_code, other.globs, other.annotations
+            )
         return NotImplemented
 
 
@@ -199,6 +206,20 @@ class MethodMaker:
             # descriptor. Don't try to rename.
             pass
 
+        # Apply annotations
+        if gen.annotations is not None:
+            if sys.version_info >= (3, 14):
+                # If __annotations__ exists on the class, either they
+                # are user defined or they are using __future__ annotations.
+                # In this case, just write __annotations__
+                if "__annotations__" in gen_cls.__dict__:
+                    method.__annotations__ = gen.annotations
+                else:
+                    anno_func = make_annotate_func(gen.annotations)
+                    method.__annotate__ = anno_func
+            else:
+                method.__annotations__ = gen.annotations
+
         # Replace this descriptor on the class with the generated function
         setattr(gen_cls, self.funcname, method)
 
@@ -217,15 +238,23 @@ class _SignatureMaker:
     # help(cls) will fail along with inspect.signature(cls)
     # This signature maker descriptor is placed to override __signature__ and force
     # the `__init__` signature to be generated first if the signature is requested.
-    def __get__(self, instance, cls):
-        import inspect  # Deferred inspect import
-        _ = cls.__init__  # force generation of `__init__` function
-        # Remove this attribute from the class
-        # This prevents recursion back into this __get__ method.
-        delattr(cls, "__signature__")
-        sig = inspect.signature(cls)
-        setattr(cls, "__signature__", sig)
-        return sig
+    def __get__(self, instance, cls=None):
+        if cls is None:
+            cls = type(instance)
+
+        # force generation of `__init__` function
+        _ = cls.__init__
+
+        if instance is None:
+            raise AttributeError(
+                f"type object {cls.__name__!r} "
+                "has no attribute '__signature__'"
+            )
+        else:
+            raise AttributeError(
+                f"{cls.__name__!r} object"
+                "has no attribute '__signature__'"
+            )
 
 
 signature_maker = _SignatureMaker()
@@ -393,7 +422,7 @@ def replace_generator(cls, funcname="__replace__"):
     # Generate the replace method for built classes
     # unlike the dataclasses implementation this is generated
     attribs = get_fields(cls)
-    
+
     # This is essentially the as_dict generator for prefabs
     # except based on attrib.init instead of .serialize
     vals = ", ".join(
@@ -407,7 +436,7 @@ def replace_generator(cls, funcname="__replace__"):
         f"def {funcname}(self, /, **changes):\n"
         f"    new_kwargs = {init_dict}\n"
         f"    for name, value in changes.items():\n"
-        f"        if name not in new_kwargs:\n"    
+        f"        if name not in new_kwargs:\n"
         f"            raise TypeError(\n"
         f"                f\"{{name!r}} is not a valid replacable \"\n"
         f"                f\"field on {{self.__class__.__name__!r}}\"\n"
@@ -578,7 +607,7 @@ class SlotMakerMeta(type):
     def __new__(cls, name, bases, ns, slots=True, gatherer=None, **kwargs):
         # This should only run if slots=True is declared
         # and __slots__ have not already been defined
-        if slots and "__slots__" not in ns:            
+        if slots and "__slots__" not in ns:
             # Check if a different gatherer has been set in any base classes
             # Default to unified gatherer
             if gatherer is None:
@@ -617,7 +646,7 @@ class SlotMakerMeta(type):
             # Place pre-gathered field data - modifications are already applied
             modifications = {}
             ns[GATHERED_DATA] = fields, modifications
-        
+
         else:
             if gatherer is not None:
                 ns[META_GATHERER_NAME] = gatherer
@@ -642,7 +671,7 @@ class GatheredFields:
     def __eq__(self, other):
         if type(self) is type(other):
             return self.fields == other.fields and self.modifications == other.modifications
-        
+
     def __repr__(self):
         return f"{type(self).__name__}(fields={self.fields!r}, modifications={self.modifications!r})"
 
@@ -761,11 +790,11 @@ def _build_field():
     # Complete the construction of the Field class
     field_docs = {
         "default": "Standard default value to be used for attributes with this field.",
-        "default_factory": 
+        "default_factory":
             "A zero-argument function to be called to generate a default value, "
             "useful for mutable obects like lists.",
         "type": "The type of the attribute to be assigned by this field.",
-        "doc": 
+        "doc":
             "The documentation for the attribute that appears when calling "
             "help(...) on the class. (Only in slotted classes).",
         "init": "Include this attribute in the class __init__ parameters.",
@@ -813,7 +842,7 @@ def pre_gathered_gatherer(cls_or_ns):
         cls_dict = cls_or_ns
     else:
         cls_dict = cls_or_ns.__dict__
-    
+
     return cls_dict[GATHERED_DATA]
 
 
@@ -1043,7 +1072,7 @@ def make_unified_gatherer(
                 return anno_g(cls_dict)
 
             return attrib_g(cls_dict)
-        
+
     return field_unified_gatherer
 
 

{ducktools_classbuilder-0.10.0 → ducktools_classbuilder-0.10.2}/src/ducktools/classbuilder/__init__.pyi

@@ -1,5 +1,6 @@
 import types
 import typing
+import typing_extensions
 
 import inspect
 
@@ -39,16 +40,20 @@ class KW_ONLY(metaclass=_KW_ONLY_META): ...
 class _CodegenType(typing.Protocol):
     def __call__(self, cls: type, funcname: str = ...) -> GeneratedCode: ...
 
-
 class GeneratedCode:
-    __slots__: tuple[str, str]
+    __slots__: tuple[str, ...]
     source_code: str
     globs: dict[str, typing.Any]
+    annotations: dict[str, typing.Any]
 
-    def __init__(self, source_code: str, globs: dict[str, typing.Any]) -> None: ...
+    def __init__(
+        self,
+        source_code: str,
+        globs: dict[str, typing.Any],
+        annotations: dict[str, typing.Any] | None = ...,
+    ) -> None: ...
     def __repr__(self) -> str: ...
 
-
 class MethodMaker:
     funcname: str
     code_generator: _CodegenType
@@ -57,7 +62,7 @@ class MethodMaker:
     def __get__(self, instance, cls) -> Callable: ...
 
 class _SignatureMaker:
-    def __get__(self, instance, cls) -> inspect.Signature: ...
+    def __get__(self, instance, cls=None) -> typing_extensions.Never: ...
 
 signature_maker: _SignatureMaker
 
@@ -141,7 +146,7 @@ class Field(metaclass=SlotMakerMeta):
 
     __slots__: dict[str, str]
     __classbuilder_internals__: dict
-    __signature__: inspect.Signature
+    __signature__: _SignatureMaker
 
     def __init__(
         self,

ducktools_classbuilder-0.10.2/src/ducktools/classbuilder/_version.py

@@ -0,0 +1,2 @@
+__version__ = "0.10.2"
+__version_tuple__ = (0, 10, 2)

{ducktools_classbuilder-0.10.0 → ducktools_classbuilder-0.10.2}/src/ducktools/classbuilder/annotations.py

@@ -24,15 +24,38 @@ import sys
 
 class _LazyAnnotationLib:
     def __getattr__(self, item):
-        global _lazyannotationlib
+        global _lazy_annotationlib
         import annotationlib  # type: ignore
-        _lazyannotationlib = annotationlib
+        _lazy_annotationlib = annotationlib
         return getattr(annotationlib, item)
 
 
 _lazy_annotationlib = _LazyAnnotationLib()
 
 
+def get_func_annotations(func):
+    """
+    Given a function, return the annotations dictionary
+
+    :param func: function object
+    :return: dictionary of annotations
+    """
+    # This method exists for use by prefab in getting annotations from
+    # the __prefab_post_init__ function
+    try:
+        annotations = func.__annotations__
+    except Exception:
+        if sys.version_info >= (3, 14):
+            annotations = _lazy_annotationlib.get_annotations(
+                func,
+                format=_lazy_annotationlib.Format.FORWARDREF,
+            )
+        else:
+            raise
+
+    return annotations
+
+
 def get_ns_annotations(ns):
     """
     Given a class namespace, attempt to retrieve the
@@ -60,6 +83,36 @@ def get_ns_annotations(ns):
     return annotations
 
 
+def make_annotate_func(annos):
+    # Only used in 3.14 or later so no sys.version_info gate
+
+    type_repr = _lazy_annotationlib.type_repr
+    Format = _lazy_annotationlib.Format
+    ForwardRef = _lazy_annotationlib.ForwardRef
+    # Construct an annotation function from __annotations__
+    def annotate_func(format, /):
+        match format:
+            case Format.VALUE | Format.FORWARDREF:
+                return {
+                    k: v.evaluate(format=format)
+                    if isinstance(v, ForwardRef) else v
+                    for k, v in annos.items()
+                }
+            case Format.STRING:
+                string_annos = {}
+                for k, v in annos.items():
+                    if isinstance(v, str):
+                        string_annos[k] = v
+                    elif isinstance(v, ForwardRef):
+                        string_annos[k] = v.evaluate(format=Format.STRING)
+                    else:
+                        string_annos[k] = type_repr(v)
+                return string_annos
+            case _:
+                raise NotImplementedError(format)
+    return annotate_func
+
+
 def is_classvar(hint):
     if isinstance(hint, str):
         # String annotations, just check if the string 'ClassVar' is in there

{ducktools_classbuilder-0.10.0 → ducktools_classbuilder-0.10.2}/src/ducktools/classbuilder/annotations.pyi

@@ -1,12 +1,21 @@
+from collections.abc import Callable
 import typing
 import types
 
 _CopiableMappings = dict[str, typing.Any] | types.MappingProxyType[str, typing.Any]
 
+def get_func_annotations(
+    func: types.FunctionType,
+) -> dict[str, typing.Any]: ...
+
 def get_ns_annotations(
     ns: _CopiableMappings,
 ) -> dict[str, typing.Any]: ...
 
+def make_annotate_func(
+    annos: dict[str, typing.Any]
+) -> Callable[[int], dict[str, typing.Any]]: ...
+
 def is_classvar(
     hint: object,
 ) -> bool: ...

{ducktools_classbuilder-0.10.0 → ducktools_classbuilder-0.10.2}/src/ducktools/classbuilder/prefab.py

@@ -34,6 +34,8 @@ from . import (
     get_repr_generator,
 )
 
+from .annotations import get_func_annotations
+
 # These aren't used but are re-exported for ease of use
 # noinspection PyUnresolvedReferences
 from . import SlotFields, KW_ONLY  # noqa: F401
@@ -62,6 +64,7 @@ def get_attributes(cls):
 # Method Generators
 def init_generator(cls, funcname="__init__"):
     globs = {}
+    annotations = {}
     # Get the internals dictionary and prepare attributes
     attributes = get_attributes(cls)
     flags = get_flags(cls)
@@ -98,47 +101,35 @@ def init_generator(cls, funcname="__init__"):
             func_arglist.extend(arglist)
 
             if extra_funcname == POST_INIT_FUNC:
-                post_init_annotations.update(func.__annotations__)
+                post_init_annotations.update(get_func_annotations(func))
 
     pos_arglist = []
     kw_only_arglist = []
     for name, attrib in attributes.items():
         # post_init annotations can be used to broaden types.
-        if name in post_init_annotations:
-            globs[f"_{name}_type"] = post_init_annotations[name]
-        elif attrib.type is not NOTHING:
-            globs[f"_{name}_type"] = attrib.type
-
         if attrib.init:
+            if name in post_init_annotations:
+                annotations[name] = post_init_annotations[name]
+            elif attrib.type is not NOTHING:
+                annotations[name] = attrib.type
+
             if attrib.default is not NOTHING:
                 if isinstance(attrib.default, (str, int, float, bool)):
                     # Just use the literal in these cases
-                    if attrib.type is NOTHING:
-                        arg = f"{name}={attrib.default!r}"
-                    else:
-                        arg = f"{name}: _{name}_type = {attrib.default!r}"
+                    arg = f"{name}={attrib.default!r}"
                 else:
                     # No guarantee repr will work for other objects
                     # so store the value in a variable and put it
                     # in the globals dict for eval
-                    if attrib.type is NOTHING:
-                        arg = f"{name}=_{name}_default"
-                    else:
-                        arg = f"{name}: _{name}_type = _{name}_default"
+                    arg = f"{name}=_{name}_default"
                     globs[f"_{name}_default"] = attrib.default
             elif attrib.default_factory is not NOTHING:
                 # Use NONE here and call the factory later
                 # This matches the behaviour of compiled
-                if attrib.type is NOTHING:
-                    arg = f"{name}=None"
-                else:
-                    arg = f"{name}: _{name}_type = None"
+                arg = f"{name}=None"
                 globs[f"_{name}_factory"] = attrib.default_factory
             else:
-                if attrib.type is NOTHING:
-                    arg = name
-                else:
-                    arg = f"{name}: _{name}_type"
+                arg = name
             if attrib.kw_only or kw_only:
                 kw_only_arglist.append(arg)
             else:
@@ -208,9 +199,15 @@ def init_generator(cls, funcname="__init__"):
         f"{pre_init_call}\n"
         f"{body}\n"
         f"{post_init_call}\n"
-        )
+    )
 
-    return GeneratedCode(code, globs)
+    if annotations:
+        annotations["return"] = None
+    else:
+        # If there are no annotations, return an unannotated init function
+        annotations = None
+
+    return GeneratedCode(code, globs, annotations)
 
 
 def iter_generator(cls, funcname="__iter__"):

{ducktools_classbuilder-0.10.0 → ducktools_classbuilder-0.10.2}/src/ducktools/classbuilder/prefab.pyi

@@ -13,6 +13,7 @@ from . import (
     GeneratedCode,
     MethodMaker,
     SlotMakerMeta,
+    _SignatureMaker
 )
 
 from . import SlotFields as SlotFields, KW_ONLY as KW_ONLY
@@ -47,7 +48,7 @@ hash_maker: MethodMaker
 
 class Attribute(Field):
     __slots__: dict
-    __signature__: inspect.Signature
+    __signature__: _SignatureMaker
     __classbuilder_gathered_fields__: tuple[dict[str, Field], dict[str, typing.Any]]
 
     iter: bool

{ducktools_classbuilder-0.10.0 → ducktools_classbuilder-0.10.2}/src/ducktools_classbuilder.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ducktools-classbuilder
-Version: 0.10.0
+Version: 0.10.2
 Summary: Toolkit for creating class boilerplate generators
 Author: David C Ellis
 Project-URL: Homepage, https://github.com/davidcellis/ducktools-classbuilder

{ducktools_classbuilder-0.10.0 → ducktools_classbuilder-0.10.2}/src/ducktools_classbuilder.egg-info/SOURCES.txt

@@ -71,4 +71,6 @@ tests/prefab/test_slotted_class.py
 tests/prefab/test_subclass_implementation.py
 tests/py312_tests/test_generic_annotations.py
 tests/py314_tests/_test_support.py
-tests/py314_tests/test_forwardref_annotations.py
+tests/py314_tests/test_forwardref_annotations.py
+tests/py314_tests/test_init_signature.py
+tests/py314_tests/test_init_signature_future.py

{ducktools_classbuilder-0.10.0 → ducktools_classbuilder-0.10.2}/tests/prefab/test_init.py

@@ -260,11 +260,37 @@ def test_signature():
     import inspect
 
     init_sig = inspect.signature(TypeSignatureInit.__init__)
-    assert str(init_sig) == "(self, x: int, y: str = 'Test')"
+    assert str(init_sig) == "(self, x: int, y: str = 'Test') -> None"
 
 
 def test_partial_signature():
     import inspect
 
     init_sig = inspect.signature(PartialTypeSignatureInit.__init__)
-    assert str(init_sig) == "(self, x, y: str = 'Test')"
+    assert str(init_sig) == "(self, x, y: str = 'Test') -> None"
+
+
+def test_inherited_signature():
+    import inspect
+
+    @prefab
+    class Base:
+        x: int
+        y: str = "Base"
+
+    class Inherited(Base):
+        def __init__(self, x=42, y="Inherited") -> None:
+            self.x = x
+            self.y = y
+
+    base_signature = inspect.signature(Base)
+    inherited_signature = inspect.signature(Inherited)
+
+    assert str(base_signature) == "(x: int, y: str = 'Base') -> None"
+    assert str(inherited_signature) == "(x=42, y='Inherited') -> None"
+
+    with pytest.raises(AttributeError):
+        Base.__signature__
+
+    with pytest.raises(AttributeError):
+        Inherited.__signature__

{ducktools_classbuilder-0.10.0 → ducktools_classbuilder-0.10.2}/tests/py314_tests/test_forwardref_annotations.py

@@ -1,6 +1,6 @@
 # Bare forwardrefs only work in 3.14 or later
 
-from ducktools.classbuilder.annotations import get_ns_annotations
+from ducktools.classbuilder.annotations import get_ns_annotations, get_func_annotations
 
 from pathlib import Path
 
@@ -46,3 +46,14 @@ def test_inner_outer_ref():
     assert get_ns_annotations(cls.__dict__) == {
         "a_val": str, "b_val": int, "c_val": float
     }
+
+
+def test_func_annotations():
+    def forwardref_func(x: unknown) -> str:
+        return ''
+
+    annos = get_func_annotations(forwardref_func)
+    assert annos == {
+        'x': EqualToForwardRef("unknown", owner=forwardref_func),
+        'return': str
+    }

ducktools_classbuilder-0.10.2/tests/py314_tests/test_init_signature.py

@@ -0,0 +1,122 @@
+from annotationlib import get_annotations, Format
+
+import pytest
+
+
+from ducktools.classbuilder.prefab import Prefab, prefab
+from _test_support import EqualToForwardRef
+
+
+# Aliases for alias test
+assign_int = int
+type type_str = str
+
+
+@pytest.mark.parametrize(
+    ["format", "expected"],
+    [
+        (Format.VALUE, {"return": None, "x": str, "y": int}),
+        (Format.FORWARDREF, {"return": None, "x": str, "y": int}),
+        (Format.STRING, {"return": "None", "x": "str", "y": "int"}),
+    ]
+)
+def test_resolvable_annotations(format, expected):
+    @prefab
+    class Example:
+        x: str
+        y: int
+
+    annos = get_annotations(Example.__init__, format=format)
+
+    assert annos == expected
+
+    class Example(Prefab):
+        x: str
+        y: int
+
+    annos = get_annotations(Example.__init__, format=format)
+
+    assert annos == expected
+
+
+@pytest.mark.parametrize(
+    ["format", "expected"],
+    [
+        (Format.VALUE, {"return": None, "x": str, "y": int}),
+        (Format.FORWARDREF, {"return": None, "x": str, "y": int}),
+        (Format.STRING, {"return": "None", "x": "str", "y": "late_definition"}),
+    ]
+)
+def test_late_defined_annotations(format, expected):
+    # Test where the annotation is a forwardref at processing time
+    @prefab
+    class Example:
+        x: str
+        y: late_definition
+
+    late_definition = int
+
+    annos = get_annotations(Example.__init__, format=format)
+
+    assert annos == expected
+
+
+@pytest.mark.parametrize(
+    ["format", "expected"],
+    [
+        (Format.VALUE, {"return": None, "x": int, "y": type_str}),
+        (Format.FORWARDREF, {"return": None, "x": int, "y": type_str}),
+        (Format.STRING, {"return": "None", "x": "int", "y": "type_str"}),
+    ]
+)
+def test_alias_defined_annotations(format, expected):
+    # Test the behaviour of type aliases and regular types
+    # Type Alias names should be kept while regular assignments will be lost
+
+    @prefab
+    class Example:
+        x: assign_int  # type: ignore
+        y: type_str
+
+    annos = get_annotations(Example.__init__, format=format)
+
+    assert annos == expected
+
+
+@pytest.mark.parametrize(
+    ["format", "expected"],
+    [
+        (Format.FORWARDREF, {"return": None, "x": str, "y": EqualToForwardRef("undefined")}),
+        (Format.STRING, {"return": "None", "x": "str", "y": "undefined"}),
+    ]
+)
+def test_forwardref_annotation(format, expected):
+    # Test where the annotation is a forwardref at processing and analysis
+    class Example(Prefab):
+        x: str
+        y: undefined
+
+    annos = get_annotations(Example.__init__, format=format)
+
+    assert annos == expected
+
+
+def test_forwardref_raises():
+    # Should still raise a NameError with VALUE annotations
+    @prefab
+    class Example:
+        x: str
+        y: undefined
+
+    with pytest.raises(NameError):
+        annos = get_annotations(Example.__init__, format=Format.VALUE)
+
+
+def test_raises_with_fake_globals():
+    @prefab
+    class Example:
+        x: str
+        y: undefined
+
+    with pytest.raises(NotImplementedError):
+        annos = Example.__init__.__annotate__(Format.VALUE_WITH_FAKE_GLOBALS)