ducktools-classbuilder 0.10.1__py3-none-any.whl → 0.10.2__py3-none-any.whl

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)
 

ducktools/classbuilder/__init__.pyi

@@ -40,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

ducktools/classbuilder/_version.py

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

ducktools/classbuilder/annotations.py

@@ -24,9 +24,9 @@ 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)
 
 
@@ -83,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/annotations.pyi

@@ -1,3 +1,4 @@
+from collections.abc import Callable
 import typing
 import types
 
@@ -11,6 +12,10 @@ 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/prefab.py

@@ -64,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)
@@ -106,41 +107,29 @@ def init_generator(cls, funcname="__init__"):
     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:
@@ -206,13 +195,19 @@ def init_generator(cls, funcname="__init__"):
         post_init_call = ""
 
     code = (
-        f"def {funcname}(self, {args}) -> None:\n"
+        f"def {funcname}(self, {args}):\n"
         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.1.dist-info → ducktools_classbuilder-0.10.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ducktools-classbuilder
-Version: 0.10.1
+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.2.dist-info/RECORD

@@ -0,0 +1,13 @@
+ducktools/classbuilder/__init__.py,sha256=uTJI45-T5ZENOfN5CqnPJRujendDYwQsu0A-zsOdIho,38198
+ducktools/classbuilder/__init__.pyi,sha256=gL_YMTFovtD0vTPeBH-wkiy_l761bxItruIBRs6Aouw,8302
+ducktools/classbuilder/_version.py,sha256=DH400d3tmKMEKy7OEfbyeJl0NAXPlOLDwet_95nLc-M,54
+ducktools/classbuilder/annotations.py,sha256=JtL8RhNp5hB_dfUju_zsqI19F9yTRQ1uM5ZTpas-VVw,4753
+ducktools/classbuilder/annotations.pyi,sha256=oUTN_ee7DWCz4CI36I7mAD43Bxlz_e5ises_VNnCX9g,480
+ducktools/classbuilder/prefab.py,sha256=UiYBvVSWM4BB4JGwUkYtG9QhPK8TzCYUiey_dgNejo8,24345
+ducktools/classbuilder/prefab.pyi,sha256=eZLjFhM-oHeRBONpCWSb1wLJKGs5Xiq0w_Jeor8Go-w,6525
+ducktools/classbuilder/py.typed,sha256=la67KBlbjXN-_-DfGNcdOcjYumVpKG_Tkw-8n5dnGB4,8
+ducktools_classbuilder-0.10.2.dist-info/licenses/LICENSE,sha256=6Thz9Dbw8R4fWInl6sGl8Rj3UnKnRbDwrc6jZerpugQ,1070
+ducktools_classbuilder-0.10.2.dist-info/METADATA,sha256=bL2jfRX1oqIJGKySrWwdEHsX_8gpOHCFPRy9i66fQnQ,9231
+ducktools_classbuilder-0.10.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ducktools_classbuilder-0.10.2.dist-info/top_level.txt,sha256=uSDLtio3ZFqdwcsMJ2O5yhjB4Q3ytbBWbA8rJREganc,10
+ducktools_classbuilder-0.10.2.dist-info/RECORD,,

ducktools_classbuilder-0.10.1.dist-info/RECORD

@@ -1,13 +0,0 @@
-ducktools/classbuilder/__init__.py,sha256=zJuGJ8_1EPEYJqO0XXDuknwGD1MxPJSZXS5_wFAW6B0,37299
-ducktools/classbuilder/__init__.pyi,sha256=NazFRfLcMpU533jGixaWHV_kARtc9J4-xXX-gkD8rFY,8177
-ducktools/classbuilder/_version.py,sha256=kdUPXlUQWcTv2wnqFkwrCx7Ue7WU2JVPnG1UU0gmLck,54
-ducktools/classbuilder/annotations.py,sha256=ImEEuzEFUrGNRMlAl7YN-H8PZT1FOK8D_yL1LygNdmo,3626
-ducktools/classbuilder/annotations.pyi,sha256=zAKJbEN1klvZu71ShuvKbf6OE7ddKb5USC6MbOjRPfY,336
-ducktools/classbuilder/prefab.py,sha256=RJfOv9yzJsySaBz6w4e5ZP8Q7K3LWX6_Buuh2zD9YDQ,24689
-ducktools/classbuilder/prefab.pyi,sha256=eZLjFhM-oHeRBONpCWSb1wLJKGs5Xiq0w_Jeor8Go-w,6525
-ducktools/classbuilder/py.typed,sha256=la67KBlbjXN-_-DfGNcdOcjYumVpKG_Tkw-8n5dnGB4,8
-ducktools_classbuilder-0.10.1.dist-info/licenses/LICENSE,sha256=6Thz9Dbw8R4fWInl6sGl8Rj3UnKnRbDwrc6jZerpugQ,1070
-ducktools_classbuilder-0.10.1.dist-info/METADATA,sha256=LkjNjXyb49v3vYBEvbldkThl9xAgCHhVc8dPNgiMsxw,9231
-ducktools_classbuilder-0.10.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ducktools_classbuilder-0.10.1.dist-info/top_level.txt,sha256=uSDLtio3ZFqdwcsMJ2O5yhjB4Q3ytbBWbA8rJREganc,10
-ducktools_classbuilder-0.10.1.dist-info/RECORD,,