ducktools-classbuilder 0.5.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

ducktools/classbuilder/__init__.py

@@ -21,7 +21,7 @@
 # SOFTWARE.
 import sys
 
-__version__ = "v0.5.0"
+__version__ = "v0.5.1"
 
 # Change this name if you make heavy modifications
 INTERNALS_DICT = "__classbuilder_internals__"
@@ -359,8 +359,19 @@ class Field:
         return cls(**argument_dict)
 
 
+class GatheredFields:
+    __slots__ = ("fields", "modifications")
+
+    def __init__(self, fields, modifications):
+        self.fields = fields
+        self.modifications = modifications
+
+    def __call__(self, cls):
+        return self.fields, self.modifications
+
+
 # Use the builder to generate __repr__ and __eq__ methods
-# and pretend `Field` was a built class all along.
+# for both Field and GatheredFields
 _field_internal = {
     "default": Field(default=NOTHING),
     "default_factory": Field(default=NOTHING),
@@ -368,17 +379,29 @@ _field_internal = {
     "doc": Field(default=None),
 }
 
+_gathered_field_internal = {
+    "fields": Field(default=NOTHING),
+    "modifications": Field(default=NOTHING),
+}
+
 _field_methods = {repr_maker, eq_maker}
 if _UNDER_TESTING:
     _field_methods.update({frozen_setattr_maker, frozen_delattr_maker})
 
 builder(
     Field,
-    gatherer=lambda cls_: (_field_internal, {}),
+    gatherer=GatheredFields(_field_internal, {}),
     methods=_field_methods,
     flags={"slotted": True, "kw_only": True},
 )
 
+builder(
+    GatheredFields,
+    gatherer=GatheredFields(_gathered_field_internal, {}),
+    methods={repr_maker, eq_maker},
+    flags={"slotted": True, "kw_only": False},
+)
+
 
 # Slot gathering tools
 # Subclass of dict to be identifiable by isinstance checks
@@ -430,6 +453,13 @@ def make_slot_gatherer(field_type=Field):
         slot_replacement = {}
 
         for k, v in cls_slots.items():
+            # Special case __dict__ and __weakref__
+            # They should be included in the final `__slots__`
+            # But ignored as a value.
+            if k in {"__dict__", "__weakref__"}:
+                slot_replacement[k] = None
+                continue
+
             if isinstance(v, field_type):
                 attrib = v
                 if attrib.type is not NOTHING:

ducktools/classbuilder/__init__.pyi

@@ -92,6 +92,25 @@ class Field:
     def from_field(cls, fld: Field, /, **kwargs: typing.Any) -> Field: ...
 
 
+class GatheredFields:
+    __slots__ = ("fields", "modifications")
+
+    fields: dict[str, Field]
+    modifications: dict[str, typing.Any]
+
+    __classbuilder_internals__: dict
+
+    def __init__(
+        self,
+        fields: dict[str, Field],
+        modifications: dict[str, typing.Any]
+    ) -> None: ...
+
+    def __repr__(self) -> str: ...
+    def __eq__(self, other) -> bool: ...
+    def __call__(self, cls: type) -> tuple[dict[str, Field], dict[str, typing.Any]]: ...
+
+
 class SlotFields(dict):
     ...
 

ducktools/classbuilder/prefab.py

@@ -30,7 +30,7 @@ import sys
 
 from . import (
     INTERNALS_DICT, NOTHING,
-    Field, MethodMaker, SlotFields,
+    Field, MethodMaker, SlotFields, GatheredFields,
     builder, fieldclass, get_flags, get_fields, make_slot_gatherer,
     frozen_setattr_maker, frozen_delattr_maker, is_classvar,
 )
@@ -519,6 +519,7 @@ def _make_prefab(
     frozen=False,
     dict_method=False,
     recursive_repr=False,
+    gathered_fields=None,
 ):
     """
     Generate boilerplate code for dunder methods in a class.
@@ -535,6 +536,7 @@ def _make_prefab(
                    such as lists)
     :param dict_method: Include an as_dict method for faster dictionary creation
     :param recursive_repr: Safely handle repr in case of recursion
+    :param gathered_fields: Pre-gathered fields callable, to skip re-collecting attributes
     :return: class with __ methods defined
     """
     cls_dict = cls.__dict__
@@ -546,12 +548,16 @@ def _make_prefab(
         )
 
     slots = cls_dict.get("__slots__")
-    if isinstance(slots, SlotFields):
-        gatherer = slot_prefab_gatherer
-        slotted = True
+    if gathered_fields is None:
+        if isinstance(slots, SlotFields):
+            gatherer = slot_prefab_gatherer
+            slotted = True
+        else:
+            gatherer = attribute_gatherer
+            slotted = False
     else:
-        gatherer = attribute_gatherer
-        slotted = False
+        gatherer = gathered_fields
+        slotted = False if slots is None else True
 
     methods = set()
 
@@ -770,6 +776,7 @@ def build_prefab(
     frozen=False,
     dict_method=False,
     recursive_repr=False,
+    slots=False,
 ):
     """
     Dynamically construct a (dynamic) prefab.
@@ -790,12 +797,35 @@ def build_prefab(
                    (This does not prevent the modification of mutable attributes such as lists)
     :param dict_method: Include an as_dict method for faster dictionary creation
     :param recursive_repr: Safely handle repr in case of recursion
+    :param slots: Make the resulting class slotted
     :return: class with __ methods defined
     """
-    class_dict = {} if class_dict is None else class_dict
-    cls = type(class_name, bases, class_dict)
+    class_dict = {} if class_dict is None else class_dict.copy()
+
+    class_annotations = {}
+    class_slots = {}
+    fields = {}
+
     for name, attrib in attributes:
-        setattr(cls, name, attrib)
+        if isinstance(attrib, Attribute):
+            fields[name] = attrib
+        elif isinstance(attrib, Field):
+            fields[name] = Attribute.from_field(attrib)
+        else:
+            fields[name] = Attribute(default=attrib)
+
+        if attrib.type is not NOTHING:
+            class_annotations[name] = attrib.type
+
+        class_slots[name] = attrib.doc
+
+    if slots:
+        class_dict["__slots__"] = class_slots
+
+    class_dict["__annotations__"] = class_annotations
+    cls = type(class_name, bases, class_dict)
+
+    gathered_fields = GatheredFields(fields, {})
 
     cls = _make_prefab(
         cls,
@@ -808,6 +838,7 @@ def build_prefab(
         frozen=frozen,
         dict_method=dict_method,
         recursive_repr=recursive_repr,
+        gathered_fields=gathered_fields,
     )
 
     return cls

ducktools/classbuilder/prefab.pyi

@@ -109,6 +109,7 @@ def _make_prefab(
     frozen: bool = False,
     dict_method: bool = False,
     recursive_repr: bool = False,
+    gathered_fields: Callable[[type], tuple[dict[str, Attribute], dict[str, typing.Any]]] | None = None,
 ) -> type: ...
 
 _T = typing.TypeVar("_T")
@@ -146,6 +147,7 @@ def build_prefab(
     frozen: bool = False,
     dict_method: bool = False,
     recursive_repr: bool = False,
+    slots: bool = False,
 ) -> type: ...
 
 def is_prefab(o: typing.Any) -> bool: ...

{ducktools_classbuilder-0.5.0.dist-info → ducktools_classbuilder-0.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ducktools-classbuilder
-Version: 0.5.0
+Version: 0.5.1
 Summary: Toolkit for creating class boilerplate generators
 Author: David C Ellis
 License: MIT License

ducktools_classbuilder-0.5.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+ducktools/classbuilder/__init__.py,sha256=rl5oc0azae-32EjeCTzhM1DR5JNR-AgOriyH5zkf4WI,20856
+ducktools/classbuilder/__init__.pyi,sha256=5gnHhSVMP5yArA-_cuvIeLnLAlmY_EmPMfVY9dRi0CA,4784
+ducktools/classbuilder/prefab.py,sha256=K9_bKh24OiGJ40BbJWVfwDObArMUxi2JRbB5ZN-t--M,28984
+ducktools/classbuilder/prefab.pyi,sha256=sNladRJM3lcZo8zQWvWCIInBx0wUD7PT6fhdE89OpG0,3960
+ducktools/classbuilder/py.typed,sha256=la67KBlbjXN-_-DfGNcdOcjYumVpKG_Tkw-8n5dnGB4,8
+ducktools_classbuilder-0.5.1.dist-info/LICENSE.md,sha256=6Thz9Dbw8R4fWInl6sGl8Rj3UnKnRbDwrc6jZerpugQ,1070
+ducktools_classbuilder-0.5.1.dist-info/METADATA,sha256=B0KO5vvdZOUZ4o28GA4zlgXuIkA9j4SuplzFByvRhjs,10143
+ducktools_classbuilder-0.5.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+ducktools_classbuilder-0.5.1.dist-info/top_level.txt,sha256=uSDLtio3ZFqdwcsMJ2O5yhjB4Q3ytbBWbA8rJREganc,10
+ducktools_classbuilder-0.5.1.dist-info/RECORD,,

ducktools_classbuilder-0.5.0.dist-info/RECORD

@@ -1,10 +0,0 @@
-ducktools/classbuilder/__init__.py,sha256=aB88mFw6bv5wzlZY88ZoCiWic3YMW3naxXmPhwT_fbs,20045
-ducktools/classbuilder/__init__.pyi,sha256=rFNQYj_TeikQMGV-NCDD4fL9l9od7NkGRoIIyABItoQ,4310
-ducktools/classbuilder/prefab.py,sha256=od-GEAYQokPDUePMOb2zPFGfh5p6zToJ-oEYpZx5CLA,28017
-ducktools/classbuilder/prefab.pyi,sha256=f7GWVTyuQUU6EO6l0eDoiKy4uUq0DxK2ndHhJ0AGeKk,3830
-ducktools/classbuilder/py.typed,sha256=la67KBlbjXN-_-DfGNcdOcjYumVpKG_Tkw-8n5dnGB4,8
-ducktools_classbuilder-0.5.0.dist-info/LICENSE.md,sha256=6Thz9Dbw8R4fWInl6sGl8Rj3UnKnRbDwrc6jZerpugQ,1070
-ducktools_classbuilder-0.5.0.dist-info/METADATA,sha256=50Jn1_0FD2BadATbyBWOQTz3fIxV1cJ36J3frvp8qBY,10143
-ducktools_classbuilder-0.5.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-ducktools_classbuilder-0.5.0.dist-info/top_level.txt,sha256=uSDLtio3ZFqdwcsMJ2O5yhjB4Q3ytbBWbA8rJREganc,10
-ducktools_classbuilder-0.5.0.dist-info/RECORD,,