ducktools-classbuilder 0.7.0__tar.gz → 0.7.1__tar.gz

{ducktools_classbuilder-0.7.0 → ducktools_classbuilder-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ducktools-classbuilder
-Version: 0.7.0
+Version: 0.7.1
 Summary: Toolkit for creating class boilerplate generators
 Author: David C Ellis
 License: MIT License
@@ -32,6 +32,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Operating System :: OS Independent
 Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.8

{ducktools_classbuilder-0.7.0 → ducktools_classbuilder-0.7.1}/docs/extension_examples.md

@@ -84,7 +84,7 @@ def iter_generator(cls, funcname="__iter__"):
     field_yield = "\n".join(f"    yield self.{f}" for f in field_names)
     if not field_yield:
         field_yield = "    yield from ()"
-    code = f"def {funcname}(self):\n" f"{field_yield}"
+    code = f"def {funcname}(self):\n{field_yield}"
     globs = {}
     return GeneratedCode(code, globs)
 
@@ -330,7 +330,7 @@ if __name__ == "__main__":
 
 This seems to be a feature people keep requesting for `dataclasses`.
 
-To implement this you simply need to create a new annotated_gatherer function.
+To implement this you need to create a new annotated_gatherer function.
 
 > Note: Field classes will be frozen when running under pytest.
 >       They should not be mutated by gatherers.

{ducktools_classbuilder-0.7.0 → ducktools_classbuilder-0.7.1}/docs/tutorial.md

@@ -1,6 +1,6 @@
 # Tutorial: Making a class boilerplate generator #
 
-The core idea is that there are 3 parts to the process of generating
+The core idea is that there are 4 parts to the process of generating
 the class boilerplate that need to be handled:
 
 1. Create a new subclass of `Field` if you need to add any extra attributes to fields
@@ -162,7 +162,7 @@ print(report_generator(CodegenDemo).source_code)
 Here we will make both a simple decorator based builder and then a subclass
 based builder that can create `__slots__`.
 
-### Decorator builder ###
+### 4a: Decorator builder ###
 ```python
 def reportclass(cls):
     gatherer = fields_attribute_gatherer
@@ -177,21 +177,22 @@ def reportclass(cls):
     flags = {"slotted": slotted}
 
     return dtbuild.builder(cls, gatherer=gatherer, methods=methods, flags=flags)
+```
 
-# Step 4b: Define a base class builder
+### 4b: Base class Builder ###
+```python
 # Once slots have been made, slot_gatherer should be used.
 slot_gatherer = dtbuild.make_slot_gatherer(CustomField)
-```
 
-### Base class Builder ###
-```python
+
 class ReportClass(metaclass=dtbuild.SlotMakerMeta):
     __slots__ = {}
     _meta_gatherer = fields_attribute_gatherer
 
     def __init_subclass__(cls):
-        slotted = '__slots__' in vars(cls) and isinstance(cls.__slots__, dtbuild.SlotFields)
-        gatherer = slot_gatherer if slotted else fields_attribute_gatherer
+        # Check if the metaclass has generated slots
+        meta_slotted = '__slots__' in vars(cls) and isinstance(cls.__slots__, dtbuild.SlotFields)
+        gatherer = slot_gatherer if meta_slotted else fields_attribute_gatherer
         methods = {
             dtbuild.eq_maker,
             dtbuild.repr_maker,
@@ -199,6 +200,7 @@ class ReportClass(metaclass=dtbuild.SlotMakerMeta):
             report_maker
         }
 
+        # The class may still have slots unrelated to code generation
         slotted = "__slots__" in vars(cls)
         flags = {"slotted": slotted}
 

{ducktools_classbuilder-0.7.0 → ducktools_classbuilder-0.7.1}/docs_code/docs_ex3_iterable.py

@@ -13,7 +13,7 @@ def iter_generator(cls, funcname="__iter__"):
     field_yield = "\n".join(f"    yield self.{f}" for f in field_names)
     if not field_yield:
         field_yield = "    yield from ()"
-    code = f"def {funcname}(self):\n" f"{field_yield}"
+    code = f"def {funcname}(self):\n{field_yield}"
     globs = {}
     return GeneratedCode(code, globs)
 

{ducktools_classbuilder-0.7.0 → ducktools_classbuilder-0.7.1}/docs_code/tutorial_code.py

@@ -117,8 +117,9 @@ class ReportClass(metaclass=dtbuild.SlotMakerMeta):
     _meta_gatherer = fields_attribute_gatherer
 
     def __init_subclass__(cls):
-        slotted = '__slots__' in vars(cls) and isinstance(cls.__slots__, dtbuild.SlotFields)
-        gatherer = slot_gatherer if slotted else fields_attribute_gatherer
+        # Check if the metaclass has generated slots
+        meta_slotted = '__slots__' in vars(cls) and isinstance(cls.__slots__, dtbuild.SlotFields)
+        gatherer = slot_gatherer if meta_slotted else fields_attribute_gatherer
         methods = {
             dtbuild.eq_maker,
             dtbuild.repr_maker,
@@ -126,6 +127,7 @@ class ReportClass(metaclass=dtbuild.SlotMakerMeta):
             report_maker
         }
 
+        # The class may still have slots unrelated to code generation
         slotted = "__slots__" in vars(cls)
         flags = {"slotted": slotted}
 

{ducktools_classbuilder-0.7.0 → ducktools_classbuilder-0.7.1}/pyproject.toml

@@ -20,6 +20,7 @@ classifiers = [
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Operating System :: OS Independent",
     "License :: OSI Approved :: MIT License",
 ]

{ducktools_classbuilder-0.7.0 → ducktools_classbuilder-0.7.1}/src/ducktools/classbuilder/__init__.py

@@ -707,10 +707,6 @@ def make_slot_gatherer(field_type=Field):
                 "in order to generate a slotclass"
             )
 
-        # Don't want to mutate original annotations so make a copy if it exists
-        # Looking at the dict is a Python3.9 or earlier requirement
-        cls_annotations = get_ns_annotations(cls_dict)
-
         cls_fields = {}
         slot_replacement = {}
 
@@ -724,8 +720,6 @@ def make_slot_gatherer(field_type=Field):
 
             if isinstance(v, field_type):
                 attrib = v
-                if attrib.type is not NOTHING:
-                    cls_annotations[k] = attrib.type
             else:
                 # Plain values treated as defaults
                 attrib = field_type(default=v)
@@ -738,7 +732,6 @@ def make_slot_gatherer(field_type=Field):
         # In this case, slots with documentation and new annotations.
         modifications = {
             "__slots__": slot_replacement,
-            "__annotations__": cls_annotations,
         }
 
         return cls_fields, modifications

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

@@ -0,0 +1,2 @@
+__version__ = "0.7.1"
+__version_tuple__ = (0, 7, 1)

{ducktools_classbuilder-0.7.0 → ducktools_classbuilder-0.7.1}/src/ducktools/classbuilder/annotations.py

@@ -24,6 +24,19 @@ import sys
 import builtins
 
 
+# Evil stuff from types.py
+def _cell_factory():
+    a = 1
+
+    def f():
+        nonlocal a
+    return f.__closure__[0]
+_FunctionType = type(_cell_factory)
+_CellType = type(_cell_factory())
+del _cell_factory
+# End evil stuff from types.py
+
+
 class _StringGlobs(dict):
     """
     Based on the fake globals dictionary used for annotations
@@ -99,6 +112,62 @@ def eval_hint(hint, context=None, *, recursion_limit=2):
     return hint
 
 
+def call_annotate_func(annotate):
+    # Python 3.14 breaks the old methods of getting annotations
+    # The new annotationlib currently relies on 'ast' and 'functools'
+    # that this project tries to avoid importing.
+
+    # The basic logic is copied from there, however, replacing ForwardRef
+    # with a more basic class.
+    # While `annotationlib` is trying to return ForwardRef objects that can
+    # be evaluated later, this module only cares about annotations that can
+    # be evaluated at the point this function is called.
+    # As such we throw away the other information and just return strings
+    # instead of forwardrefs.
+
+    try:
+        raw_annotations = annotate(1)
+    except NameError:
+        pass
+    else:
+        return raw_annotations
+
+    # The annotate func may support forwardref natively
+    try:
+        raw_annotations = annotate(2)
+    except NotImplementedError:
+        pass
+    else:
+        return raw_annotations
+
+    # Not supported so we have to implement our own deferred handling
+    # Some modified logic from annotationlib
+    namespace = {**annotate.__builtins__, **annotate.__globals__}
+    globs = _StringGlobs(namespace)
+
+    # This handles closures where the variable is defined after get annotations is called.
+    if annotate.__closure__:
+        freevars = annotate.__code__.co_freevars
+        new_closure = []
+        for i, cell in enumerate(annotate.__closure__):
+            try:
+                cell.cell_contents
+            except ValueError:
+                if i < len(freevars):
+                    name = freevars[i]
+                else:
+                    name = "__cell__"
+                new_closure.append(_CellType(name))
+            else:
+                new_closure.append(cell)
+        closure = tuple(new_closure)
+    else:
+        closure = None
+
+    new_annotate = _FunctionType(annotate.__code__, globs, closure=closure)
+    return new_annotate(1)
+
+
 def get_ns_annotations(ns, eval_str=True):
     """
     Given a class namespace, attempt to retrieve the
@@ -112,36 +181,50 @@ def get_ns_annotations(ns, eval_str=True):
     :param eval_str: Attempt to evaluate string annotations (default to True)
     :return: dictionary of evaluated annotations
     """
-    raw_annotations = ns.get("__annotations__", {})
 
-    if not eval_str:
-        return raw_annotations.copy()
+    # In 3.14 the 'canonical' method of getting annotations is to use __annotate__
+    # If this doesn't exist, check __annotations__ and treat as 3.13 or earlier.
+    annotate = ns.get("__annotate__")
 
-    try:
-        obj_modulename = ns["__module__"]
-    except KeyError:
-        obj_module = None
+    if annotate is not None:
+        raw_annotations = call_annotate_func(annotate)
     else:
-        obj_module = sys.modules.get(obj_modulename, None)
+        raw_annotations = ns.get("__annotations__", {})
 
-    if obj_module:
-        obj_globals = vars(obj_module)
-    else:
-        obj_globals = {}
+    # Unlike annotationlib we still try to evaluate string annotations
+    # This will catch cases where someone has used a literal string for a
+    # single attribute.
+    if eval_str:
+        try:
+            obj_modulename = ns["__module__"]
+        except KeyError:
+            obj_module = None
+        else:
+            obj_module = sys.modules.get(obj_modulename, None)
+
+        if obj_module:
+            obj_globals = vars(obj_module)
+        else:
+            obj_globals = {}
 
-    # Type parameters should be usable in hints without breaking
-    # This is for Python 3.12+
-    type_params = {
-        repr(param): param
-        for param in ns.get("__type_params__", ())
-    }
+        # Type parameters should be usable in hints without breaking
+        # This is for Python 3.12+
+        type_params = {
+            repr(param): param
+            for param in ns.get("__type_params__", ())
+        }
 
-    context = {**vars(builtins), **obj_globals, **type_params, **ns}
+        context = {**vars(builtins), **obj_globals, **type_params, **ns}
+
+        annotations = {
+            k: eval_hint(v, context)
+            for k, v in raw_annotations.items()
+        }
+
+    else:
+        annotations = raw_annotations.copy()
 
-    return {
-        k: eval_hint(v, context)
-        for k, v in raw_annotations.items()
-    }
+    return annotations
 
 
 def is_classvar(hint):

{ducktools_classbuilder-0.7.0 → ducktools_classbuilder-0.7.1}/src/ducktools/classbuilder/annotations.pyi

@@ -1,3 +1,4 @@
+from collections.abc import Callable
 import typing
 import types
 
@@ -8,6 +9,11 @@ class _StringGlobs(dict):
     def __missing__(self, key: _T) -> _T: ...
 
 
+def call_annotate_func(
+        annotate: Callable[[int], dict[str, type | typing.ForwardRef]]
+) -> dict[str, type | str]: ...
+
+
 def eval_hint(
     hint: type | str,
     context: None | dict[str, typing.Any] = None,

{ducktools_classbuilder-0.7.0 → ducktools_classbuilder-0.7.1}/src/ducktools_classbuilder.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ducktools-classbuilder
-Version: 0.7.0
+Version: 0.7.1
 Summary: Toolkit for creating class boilerplate generators
 Author: David C Ellis
 License: MIT License
@@ -32,6 +32,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Operating System :: OS Independent
 Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.8

{ducktools_classbuilder-0.7.0 → ducktools_classbuilder-0.7.1}/src/ducktools_classbuilder.egg-info/SOURCES.txt

@@ -50,6 +50,7 @@ tests/test_field_flags.py
 tests/test_slotmakermeta.py
 tests/annotations/test_annotated.py
 tests/annotations/test_annotations_module.py
+tests/annotations/test_future_annotations.py
 tests/prefab/dynamic/test_compare_attrib.py
 tests/prefab/dynamic/test_construction.py
 tests/prefab/dynamic/test_frozen.py
@@ -83,4 +84,5 @@ tests/prefab/shared/examples/fails/creation_3.py
 tests/prefab/shared/examples/fails/creation_5.py
 tests/prefab/shared/examples/fails/inheritance_1.py
 tests/prefab/shared/examples/fails/inheritance_2.py
-tests/py312_tests/test_generic_annotations.py
+tests/py312_tests/test_generic_annotations.py
+tests/py314_tests/test_forwardref_annotations.py

ducktools_classbuilder-0.7.1/tests/annotations/test_future_annotations.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from ducktools.classbuilder.annotations import get_ns_annotations
+
+from pathlib import Path
+
+global_type = int
+
+def test_bare_forwardref():
+    class Ex:
+        a: str
+        b: Path
+        c: plain_forwardref
+
+    annos = get_ns_annotations(Ex.__dict__)
+
+    assert annos == {'a': str, 'b': Path, 'c': "plain_forwardref"}
+
+
+def test_inner_outer_ref():
+
+    def make_func():
+        inner_type = str
+
+        class Inner:
+            a_val: inner_type = "hello"
+            b_val: global_type = 42
+            c_val: hyper_type = 3.14
+
+        # Try to get annotations before hyper_type exists
+        annos = get_ns_annotations(Inner.__dict__)
+
+        hyper_type = float
+
+        return Inner, annos
+
+    cls, annos = make_func()
+
+    # Only global types can be evaluated
+    assert annos == {"a_val": "inner_type", "b_val": int, "c_val": "hyper_type"}
+
+    # No extra evaluation
+    assert get_ns_annotations(cls.__dict__) == {
+        "a_val": "inner_type", "b_val": int, "c_val": "hyper_type"
+    }

{ducktools_classbuilder-0.7.0 → ducktools_classbuilder-0.7.1}/tests/conftest.py

@@ -2,9 +2,9 @@ import sys
 
 collect_ignore = []
 
-if sys.version_info < (3, 14):
+if sys.version_info < (3, 15):
     minor_ver = sys.version_info.minor
 
     collect_ignore.extend(
-        f"py3{i+1}_tests" for i in range(minor_ver, 14)
+        f"py3{i+1}_tests" for i in range(minor_ver, 15)
     )

{ducktools_classbuilder-0.7.0 → ducktools_classbuilder-0.7.1}/tests/prefab/dynamic/test_slotted_class.py

@@ -13,7 +13,6 @@ def test_basic_slotted():
         )
 
     assert SlottedPrefab.__slots__ == {"x": None, "y": "Digits of pi"}
-    assert get_ns_annotations(SlottedPrefab.__dict__) == {"y": float}
 
     ex = SlottedPrefab()
 

ducktools_classbuilder-0.7.1/tests/py314_tests/test_forwardref_annotations.py

@@ -0,0 +1,45 @@
+# Bare forwardrefs only work in 3.14 or later
+
+from ducktools.classbuilder.annotations import get_ns_annotations
+
+from pathlib import Path
+
+global_type = int
+
+def test_bare_forwardref():
+    class Ex:
+        a: str
+        b: Path
+        c: plain_forwardref
+
+    annos = get_ns_annotations(Ex.__dict__)
+
+    assert annos == {'a': str, 'b': Path, 'c': "plain_forwardref"}
+
+
+def test_inner_outer_ref():
+
+    def make_func():
+        inner_type = str
+
+        class Inner:
+            a_val: inner_type = "hello"
+            b_val: global_type = 42
+            c_val: hyper_type = 3.14
+
+        # Try to get annotations before hyper_type exists
+        annos = get_ns_annotations(Inner.__dict__)
+
+        hyper_type = float
+
+        return Inner, annos
+
+    cls, annos = make_func()
+
+    # Forwardref given as string if used before it can be evaluated
+    assert annos == {"a_val": str, "b_val": int, "c_val": "hyper_type"}
+
+    # Correctly evaluated if it exists
+    assert get_ns_annotations(cls.__dict__) == {
+        "a_val": str, "b_val": int, "c_val": float
+    }

{ducktools_classbuilder-0.7.0 → ducktools_classbuilder-0.7.1}/tests/test_core.py

@@ -188,7 +188,6 @@ def test_slot_gatherer_success():
 
     assert slots == fields
     assert modifications["__slots__"] == {"a": None, "b": None, "c": "a list", "d": None}
-    assert modifications["__annotations__"] == {"a": int, "d": str}
     assert get_ns_annotations(SlotsExample.__dict__) == {"a": int}  # Original annotations dict unmodified
 
 

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

@@ -1,2 +0,0 @@
-__version__ = "0.7.0"
-__version_tuple__ = (0, 7, 0)