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

ducktools/classbuilder/__init__.py

@@ -38,7 +38,7 @@ from ._version import __version__, __version_tuple__  # noqa: F401
 # Change this name if you make heavy modifications
 INTERNALS_DICT = "__classbuilder_internals__"
 META_GATHERER_NAME = "_meta_gatherer"
-
+GATHERED_DATA = "__classbuilder_gathered_fields__"
 
 # If testing, make Field classes frozen to make sure attributes are not
 # overwritten. When running this is a performance penalty so it is not required.
@@ -114,12 +114,16 @@ FIELD_NOTHING = _NothingType("FIELD")
 # KW_ONLY sentinel 'type' to use to indicate all subsequent attributes are
 # keyword only
 # noinspection PyPep8Naming
-class _KW_ONLY_TYPE:
+class _KW_ONLY_META(type):
     def __repr__(self):
-        return "<KW_ONLY Sentinel Object>"
+        return "<KW_ONLY Sentinel>"
 
 
-KW_ONLY = _KW_ONLY_TYPE()
+class KW_ONLY(metaclass=_KW_ONLY_META):
+    """
+    Sentinel Class to indicate that variables declared after
+    this sentinel are to be converted to KW_ONLY arguments.
+    """
 
 
 class GeneratedCode:
@@ -213,15 +217,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()
@@ -389,7 +401,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(
@@ -403,7 +415,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"
@@ -571,21 +583,25 @@ class SlotMakerMeta(type):
 
     Will not convert `ClassVar` hinted values.
     """
-    def __new__(cls, name, bases, ns, slots=True, **kwargs):
+    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:
             # Check if a different gatherer has been set in any base classes
             # Default to unified gatherer
-            gatherer = ns.get(META_GATHERER_NAME, None)
-            if not gatherer:
-                for base in bases:
-                    if g := getattr(base, META_GATHERER_NAME, None):
-                        gatherer = g
-                        break
+            if gatherer is None:
+                gatherer = ns.get(META_GATHERER_NAME, None)
+                if not gatherer:
+                    for base in bases:
+                        if g := getattr(base, META_GATHERER_NAME, None):
+                            gatherer = g
+                            break
+
+                if not gatherer:
+                    gatherer = unified_gatherer
 
-            if not gatherer:
-                gatherer = unified_gatherer
+            # Set the gatherer in the namespace
+            ns[META_GATHERER_NAME] = gatherer
 
             # Obtain slots from annotations or attributes
             cls_fields, cls_modifications = gatherer(ns)
@@ -595,14 +611,54 @@ class SlotMakerMeta(type):
                 else:
                     ns[k] = v
 
+            slots = {}
+            fields = {}
+
+            for k, v in cls_fields.items():
+                slots[k] = v.doc
+                if k not in {"__weakref__", "__dict__"}:
+                    fields[k] = v
+
             # Place slots *after* everything else to be safe
-            ns["__slots__"] = SlotFields(cls_fields)
+            ns["__slots__"] = slots
+
+            # 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
 
         new_cls = super().__new__(cls, name, bases, ns, **kwargs)
 
         return new_cls
 
 
+# This class is set up before fields as it will be used to generate the Fields
+# for Field itself so Field can have generated __eq__, __repr__ and other methods
+class GatheredFields:
+    """
+    Helper class to store gathered field data
+    """
+    __slots__ = ("fields", "modifications")
+
+    def __init__(self, fields, modifications):
+        self.fields = fields
+        self.modifications = modifications
+
+    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})"
+
+    def __call__(self, cls_dict):
+        # cls_dict will be provided, but isn't needed
+        return self.fields, self.modifications
+
+
 # The Field class can finally be defined.
 # The __init__ method has to be written manually so Fields can be created
 # However after this, the other methods can be generated.
@@ -628,17 +684,18 @@ class Field(metaclass=SlotMakerMeta):
     :param compare: Include in the class __eq__.
     :param kw_only: Make this a keyword only parameter in __init__.
     """
-    # If this base class did not define __slots__ the metaclass would break it.
-    # This will be replaced by the builder.
-    __slots__ = SlotFields(
-        default=NOTHING,
-        default_factory=NOTHING,
-        type=NOTHING,
-        doc=None,
-        init=True,
-        repr=True,
-        compare=True,
-        kw_only=False,
+
+    # Plain slots are required as part of bootstrapping
+    # This prevents SlotMakerMeta from trying to generate 'Field's
+    __slots__ = (
+        "default",
+        "default_factory",
+        "type",
+        "doc",
+        "init",
+        "repr",
+        "compare",
+        "kw_only",
     )
 
     # noinspection PyShadowingBuiltins
@@ -672,6 +729,7 @@ class Field(metaclass=SlotMakerMeta):
         self.validate_field()
 
     def __init_subclass__(cls, frozen=False):
+        # Subclasses of Field can be created as if they are dataclasses
         field_methods = {_field_init_maker, repr_maker, eq_maker}
         if frozen or _UNDER_TESTING:
             field_methods.update({frozen_setattr_maker, frozen_delattr_maker})
@@ -707,6 +765,66 @@ class Field(metaclass=SlotMakerMeta):
         return cls(**argument_dict)
 
 
+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":
+            "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":
+            "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.",
+        "repr": "Include this attribute in the class __repr__",
+        "compare": "Include this attribute in the class __eq__ method",
+        "kw_only": "Make this a keyword only parameter in __init__",
+    }
+
+    fields = {
+        "default": Field(default=NOTHING, doc=field_docs["default"]),
+        "default_factory": Field(default=NOTHING, doc=field_docs["default_factory"]),
+        "type": Field(default=NOTHING, doc=field_docs["type"]),
+        "doc": Field(default=None, doc=field_docs["doc"]),
+        "init": Field(default=True, doc=field_docs["init"]),
+        "repr": Field(default=True, doc=field_docs["repr"]),
+        "compare": Field(default=True, doc=field_docs["compare"]),
+        "kw_only": Field(default=False, doc=field_docs["kw_only"])
+    }
+    modifications = {"__slots__": field_docs}
+
+    field_methods = {repr_maker, eq_maker}
+    if _UNDER_TESTING:
+        field_methods.update({frozen_setattr_maker, frozen_delattr_maker})
+
+    builder(
+        Field,
+        gatherer=GatheredFields(fields, modifications),
+        methods=field_methods,
+        flags={"slotted": True, "kw_only": True},
+    )
+
+
+_build_field()
+del _build_field
+
+
+def pre_gathered_gatherer(cls_or_ns):
+    """
+    Retrieve fields previously gathered by SlotMakerMeta
+
+    :param cls_or_ns: Class to gather field information from (or class namespace)
+    :return: dict of field_name: Field(...) and modifications to be performed by the builder
+    """
+    if isinstance(cls_or_ns, (_MappingProxyType, dict)):
+        cls_dict = cls_or_ns
+    else:
+        cls_dict = cls_or_ns.__dict__
+
+    return cls_dict[GATHERED_DATA]
+
+
 def make_slot_gatherer(field_type=Field):
     """
     Create a new annotation gatherer that will work with `Field` instances
@@ -721,7 +839,7 @@ def make_slot_gatherer(field_type=Field):
         Gather field information for class generation based on __slots__
 
         :param cls_or_ns: Class to gather field information from (or class namespace)
-        :return: dict of field_name: Field(...)
+        :return: dict of field_name: Field(...) and modifications to be performed by the builder
         """
         if isinstance(cls_or_ns, (_MappingProxyType, dict)):
             cls_dict = cls_or_ns
@@ -883,6 +1001,7 @@ def make_field_gatherer(
 def make_unified_gatherer(
     field_type=Field,
     leave_default_values=False,
+    ignore_annotations=False,
 ):
     """
     Create a gatherer that will work via first slots, then
@@ -891,6 +1010,7 @@ def make_unified_gatherer(
 
     :param field_type: The field class to use for gathering
     :param leave_default_values: leave default values in place
+    :param ignore_annotations: don't attempt to read annotations
     :return: gatherer function
     """
     slot_g = make_slot_gatherer(field_type)
@@ -903,27 +1023,35 @@ def make_unified_gatherer(
         else:
             cls_dict = cls_or_ns.__dict__
 
+        cls_gathered = cls_dict.get(GATHERED_DATA)
+        if cls_gathered:
+            return pre_gathered_gatherer(cls_dict)
+
         cls_slots = cls_dict.get("__slots__")
 
         if isinstance(cls_slots, SlotFields):
             return slot_g(cls_dict)
 
-        # To choose between annotation and attribute gatherers
-        # compare sets of names.
-        # Don't bother evaluating string annotations, as we only need names
-        cls_annotations = get_ns_annotations(cls_dict)
-        cls_attributes = {
-            k: v for k, v in cls_dict.items() if isinstance(v, field_type)
-        }
+        if ignore_annotations:
+            return attrib_g(cls_dict)
+        else:
+            # To choose between annotation and attribute gatherers
+            # compare sets of names.
+            # Don't bother evaluating string annotations, as we only need names
+            cls_annotations = get_ns_annotations(cls_dict)
+            cls_attributes = {
+                k: v for k, v in cls_dict.items() if isinstance(v, field_type)
+            }
 
-        cls_annotation_names = cls_annotations.keys()
-        cls_attribute_names = cls_attributes.keys()
+            cls_annotation_names = cls_annotations.keys()
+            cls_attribute_names = cls_attributes.keys()
 
-        if set(cls_annotation_names).issuperset(set(cls_attribute_names)):
-            # All `Field` values have annotations, so use annotation gatherer
-            return anno_g(cls_dict)
+            if set(cls_annotation_names).issuperset(set(cls_attribute_names)):
+                # All `Field` values have annotations, so use annotation gatherer
+                return anno_g(cls_dict)
+
+            return attrib_g(cls_dict)
 
-        return attrib_g(cls_dict)
     return field_unified_gatherer
 
 
@@ -935,19 +1063,6 @@ annotation_gatherer = make_annotation_gatherer()
 unified_gatherer = make_unified_gatherer()
 
 
-# Now the gatherers have been defined, add __repr__ and __eq__ to Field.
-_field_methods = {repr_maker, eq_maker}
-if _UNDER_TESTING:
-    _field_methods.update({frozen_setattr_maker, frozen_delattr_maker})
-
-builder(
-    Field,
-    gatherer=slot_gatherer,
-    methods=_field_methods,
-    flags={"slotted": True, "kw_only": True},
-)
-
-
 def check_argument_order(cls):
     """
     Raise a SyntaxError if the argument order will be invalid for a generated
@@ -990,17 +1105,3 @@ def slotclass(cls=None, /, *, methods=default_methods, syntax_check=True):
         check_argument_order(cls)
 
     return cls
-
-
-@slotclass
-class GatheredFields:
-    """
-    A helper gatherer for fields that have been gathered externally.
-    """
-    __slots__ = SlotFields(
-        fields=Field(),
-        modifications=Field(),
-    )
-
-    def __call__(self, cls):
-        return self.fields, self.modifications

ducktools/classbuilder/__init__.pyi

@@ -1,5 +1,6 @@
 import types
 import typing
+import typing_extensions
 
 import inspect
 
@@ -13,6 +14,7 @@ __version__: str
 __version_tuple__: tuple[str | int, ...]
 INTERNALS_DICT: str
 META_GATHERER_NAME: str
+GATHERED_DATA: str
 
 def get_fields(cls: type, *, local: bool = False) -> dict[str, Field]: ...
 
@@ -28,11 +30,11 @@ class _NothingType:
 NOTHING: _NothingType
 FIELD_NOTHING: _NothingType
 
-# noinspection PyPep8Naming
-class _KW_ONLY_TYPE:
+class _KW_ONLY_META(type):
     def __repr__(self) -> str: ...
 
-KW_ONLY: _KW_ONLY_TYPE
+class KW_ONLY(metaclass=_KW_ONLY_META): ...
+
 # Stub Only
 @typing.type_check_only
 class _CodegenType(typing.Protocol):
@@ -56,7 +58,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
 
@@ -122,7 +124,8 @@ class SlotMakerMeta(type):
         name: str,
         bases: tuple[type, ...],
         ns: dict[str, typing.Any],
-        slots: bool = True,
+        slots: bool = ...,
+        gatherer: Callable[[type], tuple[dict[str, Field], dict[str, typing.Any]]] | None = ...,
         **kwargs: typing.Any,
     ) -> _T: ...
 
@@ -139,7 +142,7 @@ class Field(metaclass=SlotMakerMeta):
 
     __slots__: dict[str, str]
     __classbuilder_internals__: dict
-    __signature__: inspect.Signature
+    __signature__: _SignatureMaker
 
     def __init__(
         self,
@@ -167,6 +170,9 @@ class Field(metaclass=SlotMakerMeta):
 _ReturnsField = Callable[..., Field]
 _FieldType = typing.TypeVar("_FieldType", bound=Field)
 
+def pre_gathered_gatherer(
+    cls_or_ns: type | _CopiableMappings
+) -> tuple[dict[str, Field | _FieldType], dict[str, typing.Any]]: ...
 
 @typing.overload
 def make_slot_gatherer(
@@ -206,13 +212,15 @@ def make_field_gatherer(
 @typing.overload
 def make_unified_gatherer(
     field_type: type[_FieldType],
-    leave_default_values: bool = False,
+    leave_default_values: bool = ...,
+    ignore_annotations: bool = ...,
 ) -> Callable[[type | _CopiableMappings], tuple[dict[str, _FieldType], dict[str, typing.Any]]]: ...
 
 @typing.overload
 def make_unified_gatherer(
-    field_type: _ReturnsField = Field,
-    leave_default_values: bool = False,
+    field_type: _ReturnsField = ...,
+    leave_default_values: bool = ...,
+    ignore_annotations: bool = ...,
 ) -> Callable[[type | _CopiableMappings], tuple[dict[str, Field], dict[str, typing.Any]]]: ...
 
 
@@ -246,7 +254,7 @@ def slotclass(
 _gatherer_type = Callable[[type | _CopiableMappings], tuple[dict[str, Field], dict[str, typing.Any]]]
 
 class GatheredFields:
-    __slots__: dict[str, None]
+    __slots__: tuple[str, ...]
 
     fields: dict[str, Field]
     modifications: dict[str, typing.Any]
@@ -262,4 +270,4 @@ class GatheredFields:
 
     def __repr__(self) -> str: ...
     def __eq__(self, other) -> bool: ...
-    def __call__(self, cls: type) -> tuple[dict[str, Field], dict[str, typing.Any]]: ...
+    def __call__(self, cls_dict: type | dict[str, typing.Any]) -> tuple[dict[str, Field], dict[str, typing.Any]]: ...

ducktools/classbuilder/_version.py

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

ducktools/classbuilder/annotations.py

@@ -33,6 +33,29 @@ class _LazyAnnotationLib:
 _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
@@ -70,19 +93,8 @@ def is_classvar(hint):
     else:
         _typing = sys.modules.get("typing")
         if _typing:
-            # Annotated is a nightmare I'm never waking up from
-            # 3.8 and 3.9 need Annotated from typing_extensions
-            # 3.8 also needs get_origin from typing_extensions
-            if sys.version_info < (3, 10):
-                _typing_extensions = sys.modules.get("typing_extensions")
-                if _typing_extensions:
-                    _Annotated = _typing_extensions.Annotated
-                    _get_origin = _typing_extensions.get_origin
-                else:
-                    _Annotated, _get_origin = None, None
-            else:
-                _Annotated = _typing.Annotated
-                _get_origin = _typing.get_origin
+            _Annotated = _typing.Annotated
+            _get_origin = _typing.get_origin
 
             if _Annotated and _get_origin(hint) is _Annotated:
                 hint = getattr(hint, "__origin__", None)

ducktools/classbuilder/annotations.pyi

@@ -3,6 +3,10 @@ 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]: ...

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
@@ -98,7 +100,7 @@ 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 = []
@@ -204,11 +206,11 @@ def init_generator(cls, funcname="__init__"):
         post_init_call = ""
 
     code = (
-        f"def {funcname}(self, {args}):\n"
+        f"def {funcname}(self, {args}) -> None:\n"
         f"{pre_init_call}\n"
         f"{body}\n"
         f"{post_init_call}\n"
-        )
+    )
 
     return GeneratedCode(code, globs)
 
@@ -551,8 +553,7 @@ def _make_prefab(
     return cls
 
 
-class Prefab(metaclass=SlotMakerMeta):
-    _meta_gatherer = prefab_gatherer
+class Prefab(metaclass=SlotMakerMeta, gatherer=prefab_gatherer):
     __slots__ = {}  # type: ignore
 
     # noinspection PyShadowingBuiltins

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,8 @@ 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
     serialize: bool

{ducktools_classbuilder-0.9.1.dist-info → ducktools_classbuilder-0.10.1.dist-info}/METADATA

@@ -1,12 +1,10 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: ducktools-classbuilder
-Version: 0.9.1
+Version: 0.10.1
 Summary: Toolkit for creating class boilerplate generators
 Author: David C Ellis
 Project-URL: Homepage, https://github.com/davidcellis/ducktools-classbuilder
 Classifier: Development Status :: 4 - Beta
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -14,22 +12,14 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Operating System :: OS Independent
 Classifier: License :: OSI Approved :: MIT License
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: docs
-Requires-Dist: sphinx ; extra == 'docs'
-Requires-Dist: myst-parser ; extra == 'docs'
-Requires-Dist: sphinx-rtd-theme ; extra == 'docs'
-Provides-Extra: performance_tests
-Requires-Dist: attrs ; extra == 'performance_tests'
-Requires-Dist: pydantic ; extra == 'performance_tests'
-Provides-Extra: testing
-Requires-Dist: pytest >=8.2 ; extra == 'testing'
-Requires-Dist: pytest-cov ; extra == 'testing'
-Requires-Dist: typing-extensions ; extra == 'testing'
-Provides-Extra: type_checking
-Requires-Dist: mypy ; extra == 'type_checking'
+Requires-Dist: sphinx>=8.1; extra == "docs"
+Requires-Dist: myst-parser>=4.0; extra == "docs"
+Requires-Dist: sphinx_rtd_theme>=3.0; extra == "docs"
+Dynamic: license-file
 
 # Ducktools: Class Builder #
 

ducktools_classbuilder-0.10.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+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,,

{ducktools_classbuilder-0.9.1.dist-info → ducktools_classbuilder-0.10.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.3.2)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

ducktools_classbuilder-0.9.1.dist-info/RECORD

@@ -1,13 +0,0 @@
-ducktools/classbuilder/__init__.py,sha256=5vagbDiErapPudNG5-gP3yarlA6-q8IriMcRrAzBBr4,33433
-ducktools/classbuilder/__init__.pyi,sha256=6nEfVyeF1HE4YlvcNkFetACqMd1EObu3hYwoLYBbRNo,7796
-ducktools/classbuilder/_version.py,sha256=Ti7IekFg9SsQHXFYa9yzblMN29C0yL2OG6aLOfnSQOc,52
-ducktools/classbuilder/annotations.py,sha256=VEZsCM8lwfhaWrQi8dUOAkicYHxUHaSAyM-FzL34wXI,3583
-ducktools/classbuilder/annotations.pyi,sha256=c5vYtULdDgMYWtkzeYMsHIbmnEuT2Ru-nNZieWvYuQ4,247
-ducktools/classbuilder/prefab.py,sha256=RiVbESwFiPv3Y4PpclSZAwdwBomILbhGEF8XHAaDzW4,24643
-ducktools/classbuilder/prefab.pyi,sha256=_Tm2V97Udt3-WlbBRuOSt11PPYdw1TrFeSd4Mcs2EKM,6422
-ducktools/classbuilder/py.typed,sha256=la67KBlbjXN-_-DfGNcdOcjYumVpKG_Tkw-8n5dnGB4,8
-ducktools_classbuilder-0.9.1.dist-info/LICENSE,sha256=6Thz9Dbw8R4fWInl6sGl8Rj3UnKnRbDwrc6jZerpugQ,1070
-ducktools_classbuilder-0.9.1.dist-info/METADATA,sha256=45E7CeSoBEii1Tra1U16WUvcBepEQ4vCsay_y_2UinY,9687
-ducktools_classbuilder-0.9.1.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-ducktools_classbuilder-0.9.1.dist-info/top_level.txt,sha256=uSDLtio3ZFqdwcsMJ2O5yhjB4Q3ytbBWbA8rJREganc,10
-ducktools_classbuilder-0.9.1.dist-info/RECORD,,