ducktools-classbuilder 0.8.1__tar.gz → 0.8.3__tar.gz

{ducktools_classbuilder-0.8.1 → ducktools_classbuilder-0.8.3}/.github/workflows/auto_test.yml

@@ -14,7 +14,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest]
-        python-version: ["3.13", "3.12", "3.11", "3.10", "pypy-3.10", "3.9", "3.8"]
+        python-version: ["3.14-dev", "3.13", "3.12", "3.11", "3.10", "pypy-3.10", "3.9", "3.8"]
 
     steps:
     - uses: actions/checkout@v4

{ducktools_classbuilder-0.8.1 → ducktools_classbuilder-0.8.3}/PKG-INFO

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

{ducktools_classbuilder-0.8.1 → ducktools_classbuilder-0.8.3}/docs/extension_examples.md

@@ -116,6 +116,25 @@ You could also choose to yield tuples of `name, value` pairs in your implementat
 
 ### Extending Field ###
 
+The `Field` class can also be extended as if it is a slotclass, with annotations or
+with `Field` declarations.
+
+One notable caveat - if you want to use a `default_factory` in extending `Field` you
+need to declare `default=FIELD_NOTHING` also in order for default to be ignored. This
+is a special case for `Field` and is not needed in general.
+
+```python
+from ducktools.classbuilder import Field, FIELD_NOTHING
+
+class MetadataField(Field):
+    metadata: dict = Field(default=FIELD_NOTHING, default_factory=dict)
+```
+
+In regular classes the `__init__` function generator considers `NOTHING` to be an 
+ignored value, but for `Field` subclasses it is a valid value so `FIELD_NOTHING` is
+the ignored term. This is all because `None` *is* a valid value and can't be used
+as a sentinel for Fields (otherwise `Field(default=None)` couldn't work).
+
 #### Positional Only Arguments? ####
 
 This is possible, but a little longer as we also need to modify multiple methods

{ducktools_classbuilder-0.8.1 → ducktools_classbuilder-0.8.3}/src/ducktools/classbuilder/__init__.py

@@ -99,11 +99,16 @@ def _get_inst_fields(inst):
 # As 'None' can be a meaningful value we need a sentinel value
 # to use to show no value has been provided.
 class _NothingType:
+    def __init__(self, custom=None):
+        self.custom = custom
     def __repr__(self):
+        if self.custom:
+            return f"<{self.custom} NOTHING OBJECT>"
         return "<NOTHING OBJECT>"
 
 
 NOTHING = _NothingType()
+FIELD_NOTHING = _NothingType("FIELD")
 
 
 # KW_ONLY sentinel 'type' to use to indicate all subsequent attributes are
@@ -432,11 +437,11 @@ frozen_setattr_maker = MethodMaker("__setattr__", frozen_setattr_generator)
 frozen_delattr_maker = MethodMaker("__delattr__", frozen_delattr_generator)
 default_methods = frozenset({init_maker, repr_maker, eq_maker})
 
-# Special `__init__` maker for 'Field' subclasses
+# Special `__init__` maker for 'Field' subclasses - needs its own NOTHING option
 _field_init_maker = MethodMaker(
     funcname="__init__",
     code_generator=get_init_generator(
-        null=_NothingType(),
+        null=FIELD_NOTHING,
         extra_code=["self.validate_field()"],
     )
 )
@@ -649,7 +654,7 @@ class Field(metaclass=SlotMakerMeta):
 
     def validate_field(self):
         cls_name = self.__class__.__name__
-        if self.default is not NOTHING and self.default_factory is not NOTHING:
+        if type(self.default) is not _NothingType and type(self.default_factory) is not _NothingType:
             raise AttributeError(
                 f"{cls_name} cannot define both a default value and a default factory."
             )
@@ -807,6 +812,7 @@ def make_annotation_gatherer(
 def make_field_gatherer(
     field_type=Field,
     leave_default_values=False,
+    assign_types=True,
 ):
     def field_attribute_gatherer(cls_or_ns):
         if isinstance(cls_or_ns, (_MappingProxyType, dict)):
@@ -819,7 +825,11 @@ def make_field_gatherer(
             for k, v in cls_dict.items()
             if isinstance(v, field_type)
         }
-        cls_annotations = get_ns_annotations(cls_dict)
+
+        if assign_types:
+            cls_annotations = get_ns_annotations(cls_dict)
+        else:
+            cls_annotations = {}
 
         cls_modifications = {}
 
@@ -830,7 +840,7 @@ def make_field_gatherer(
             else:
                 cls_modifications[name] = NOTHING
 
-            if (anno := cls_annotations.get(name, NOTHING)) is not NOTHING:
+            if assign_types and (anno := cls_annotations.get(name, NOTHING)) is not NOTHING:
                 cls_attributes[name] = field_type.from_field(attrib, type=anno)
 
         return cls_attributes, cls_modifications

{ducktools_classbuilder-0.8.1 → ducktools_classbuilder-0.8.3}/src/ducktools/classbuilder/__init__.pyi

@@ -24,8 +24,10 @@ def get_methods(cls: type) -> types.MappingProxyType[str, MethodMaker]: ...
 def _get_inst_fields(inst: typing.Any) -> dict[str, typing.Any]: ...
 
 class _NothingType:
+    def __init__(self, custom: str | None = ...) -> None: ...
     def __repr__(self) -> str: ...
 NOTHING: _NothingType
+FIELD_NOTHING: _NothingType
 
 # noinspection PyPep8Naming
 class _KW_ONLY_TYPE:
@@ -191,6 +193,7 @@ def make_annotation_gatherer(
 def make_field_gatherer(
     field_type: type[_FieldType],
     leave_default_values: bool = False,
+    assign_types: bool = True,
 ) -> Callable[[type | _CopiableMappings], tuple[dict[str, _FieldType], dict[str, typing.Any]]]: ...
 
 @typing.overload

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

@@ -0,0 +1,2 @@
+__version__ = "0.8.3"
+__version_tuple__ = (0, 8, 3)

{ducktools_classbuilder-0.8.1 → ducktools_classbuilder-0.8.3}/src/ducktools/classbuilder/annotations.py

@@ -22,6 +22,17 @@
 import sys
 
 
+class _LazyAnnotationLib:
+    def __getattr__(self, item):
+        global _lazyannotationlib
+        import annotationlib
+        _lazyannotationlib = annotationlib
+        return getattr(annotationlib, item)
+
+
+_lazy_annotationlib = _LazyAnnotationLib()
+
+
 def get_ns_annotations(ns):
     """
     Given a class namespace, attempt to retrieve the
@@ -34,20 +45,14 @@ def get_ns_annotations(ns):
     annotations = ns.get("__annotations__")
     if annotations is not None:
         annotations = annotations.copy()
-    else:
+    elif sys.version_info >= (3, 14):
         # See if we're using PEP-649 annotations
-        # Guarding this with a try/except instead of a version check
-        # In case there's a change and PEP-649 somehow doesn't make 3.14
-        try:
-            from annotationlib import Format, call_annotate_function, get_annotate_function
-        except ImportError:
-            pass
-        else:
-            annotate = ns.get("__annotate__")  # Works in the alphas, but may break
-            if not annotate:
-                annotate = get_annotate_function(ns)
-            if annotate:
-                annotations = call_annotate_function(annotate, format=Format.FORWARDREF)
+        annotate = _lazy_annotationlib.get_annotate_from_class_namespace(ns)
+        if annotate:
+            annotations = _lazy_annotationlib.call_annotate_function(
+                annotate,
+                format=_lazy_annotationlib.Format.FORWARDREF
+            )
 
     if annotations is None:
         annotations = {}
@@ -88,4 +93,3 @@ def is_classvar(hint):
             ):
                 return True
     return False
-

{ducktools_classbuilder-0.8.1 → ducktools_classbuilder-0.8.3}/src/ducktools/classbuilder/prefab.py

@@ -26,7 +26,7 @@ A 'prebuilt' implementation of class generation.
 Includes pre and post init functions along with other methods.
 """
 from . import (
-    INTERNALS_DICT, NOTHING,
+    INTERNALS_DICT, NOTHING, FIELD_NOTHING,
     Field, MethodMaker, GatheredFields, GeneratedCode, SlotMakerMeta,
     builder, get_flags, get_fields,
     make_unified_gatherer,
@@ -289,10 +289,12 @@ class Attribute(Field):
     :param kw_only: Make this argument keyword only in init
     :param serialize: Include this attribute in methods that serialize to dict
     :param doc: Parameter documentation for slotted classes
+    :param metadata: Additional non-construction related metadata
     :param type: Type of this attribute (for slotted classes)
     """
     iter: bool = True
     serialize: bool = True
+    metadata: dict = Field(default=FIELD_NOTHING, default_factory=dict)
 
 
 # noinspection PyShadowingBuiltins
@@ -309,6 +311,7 @@ def attribute(
     exclude_field=False,
     private=False,
     doc=None,
+    metadata=None,
     type=NOTHING,
 ):
     """
@@ -326,6 +329,7 @@ def attribute(
     :param exclude_field: Shorthand for setting repr, compare, iter and serialize to False
     :param private: Short for init, repr, compare, iter, serialize = False, must have default or factory
     :param doc: Parameter documentation for slotted classes
+    :param metadata: Dictionary for additional non-construction metadata
     :param type: Type of this attribute (for slotted classes)
 
     :return: Attribute generated with these parameters.
@@ -356,6 +360,7 @@ def attribute(
         serialize=serialize,
         doc=doc,
         type=type,
+        metadata=metadata,
     )
 
 

{ducktools_classbuilder-0.8.1 → ducktools_classbuilder-0.8.3}/src/ducktools/classbuilder/prefab.pyi

@@ -50,6 +50,7 @@ class Attribute(Field):
 
     iter: bool
     serialize: bool
+    metadata: dict
 
     def __init__(
         self,
@@ -64,6 +65,7 @@ class Attribute(Field):
         iter: bool = True,
         kw_only: bool = False,
         serialize: bool = True,
+        metadata: dict | None = None,
     ) -> None: ...
 
     def __repr__(self) -> str: ...
@@ -74,8 +76,6 @@ def attribute(
     *,
     default: typing.Any | _NothingType = NOTHING,
     default_factory: typing.Any | _NothingType = NOTHING,
-    type: type | _NothingType = NOTHING,
-    doc: str | None = None,
     init: bool = True,
     repr: bool = True,
     compare: bool = True,
@@ -84,6 +84,9 @@ def attribute(
     serialize: bool = True,
     exclude_field: bool = False,
     private: bool = False,
+    doc: str | None = None,
+    metadata: dict | None = None,
+    type: type | _NothingType = NOTHING,
 ) -> Attribute: ...
 
 def prefab_gatherer(cls_or_ns: type | MappingProxyType) -> tuple[dict[str, Attribute], dict[str, typing.Any]]: ...

{ducktools_classbuilder-0.8.1 → ducktools_classbuilder-0.8.3}/src/ducktools_classbuilder.egg-info/PKG-INFO

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

{ducktools_classbuilder-0.8.1 → ducktools_classbuilder-0.8.3}/src/ducktools_classbuilder.egg-info/SOURCES.txt

@@ -82,4 +82,5 @@ 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/py314_tests/_test_support.py
 tests/py314_tests/test_forwardref_annotations.py

ducktools_classbuilder-0.8.3/tests/py314_tests/_test_support.py

@@ -0,0 +1,42 @@
+from annotationlib import ForwardRef
+
+# From test/support/__init__.py
+class EqualToForwardRef:
+    """Helper to ease use of annotationlib.ForwardRef in tests.
+
+    This checks only attributes that can be set using the constructor.
+
+    """
+
+    def __init__(
+        self,
+        arg,
+        *,
+        module=None,
+        owner=None,
+        is_class=False,
+    ):
+        self.__forward_arg__ = arg
+        self.__forward_is_class__ = is_class
+        self.__forward_module__ = module
+        self.__owner__ = owner
+
+    def __eq__(self, other):
+        if not isinstance(other, (EqualToForwardRef, ForwardRef)):
+            return NotImplemented
+        return (
+            self.__forward_arg__ == other.__forward_arg__
+            and self.__forward_module__ == other.__forward_module__
+            and self.__forward_is_class__ == other.__forward_is_class__
+            and self.__owner__ == other.__owner__
+        )
+
+    def __repr__(self):
+        extra = []
+        if self.__forward_module__ is not None:
+            extra.append(f", module={self.__forward_module__!r}")
+        if self.__forward_is_class__:
+            extra.append(", is_class=True")
+        if self.__owner__ is not None:
+            extra.append(f", owner={self.__owner__!r}")
+        return f"EqualToForwardRef({self.__forward_arg__!r}{''.join(extra)})"

{ducktools_classbuilder-0.8.1 → ducktools_classbuilder-0.8.3}/tests/py314_tests/test_forwardref_annotations.py

@@ -1,12 +1,14 @@
 # Bare forwardrefs only work in 3.14 or later
 
 from ducktools.classbuilder.annotations import get_ns_annotations
-from annotationlib import ForwardRef
 
 from pathlib import Path
 
+from _test_support import EqualToForwardRef
+
 global_type = int
 
+
 def test_bare_forwardref():
     class Ex:
         a: str
@@ -15,7 +17,7 @@ def test_bare_forwardref():
 
     annos = get_ns_annotations(Ex.__dict__)
 
-    assert annos == {'a': str, 'b': Path, 'c': ForwardRef("plain_forwardref")}
+    assert annos == {'a': str, 'b': Path, 'c': EqualToForwardRef("plain_forwardref")}
 
 
 def test_inner_outer_ref():
@@ -38,7 +40,7 @@ def test_inner_outer_ref():
     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": ForwardRef("hyper_type")}
+    assert annos == {"a_val": str, "b_val": int, "c_val": EqualToForwardRef("hyper_type")}
 
     # Correctly evaluated if it exists
     assert get_ns_annotations(cls.__dict__) == {

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

@@ -1,2 +0,0 @@
-__version__ = "0.8.1"
-__version_tuple__ = (0, 8, 1)