ducktools-classbuilder 0.4.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.4.0"
+__version__ = "v0.5.1"
 
 # Change this name if you make heavy modifications
 INTERNALS_DICT = "__classbuilder_internals__"
@@ -65,7 +65,7 @@ def _get_inst_fields(inst):
     }
 
 
-# As 'None' can be a meaningful default we need a sentinel value
+# As 'None' can be a meaningful value we need a sentinel value
 # to use to show no value has been provided.
 class _NothingType:
     def __repr__(self):
@@ -109,7 +109,7 @@ class MethodMaker:
         return method.__get__(instance, cls)
 
 
-def get_init_maker(null=NOTHING, extra_code=None):
+def get_init_generator(null=NOTHING, extra_code=None):
     def cls_init_maker(cls):
         fields = get_fields(cls)
         flags = get_flags(cls)
@@ -154,10 +154,10 @@ def get_init_maker(null=NOTHING, extra_code=None):
     return cls_init_maker
 
 
-init_maker = get_init_maker()
+init_generator = get_init_generator()
 
 
-def repr_maker(cls):
+def repr_generator(cls):
     fields = get_fields(cls)
     content = ", ".join(
         f"{name}={{self.{name}!r}}"
@@ -171,7 +171,7 @@ def repr_maker(cls):
     return code, globs
 
 
-def eq_maker(cls):
+def eq_generator(cls):
     class_comparison = "self.__class__ is other.__class__"
     field_names = get_fields(cls)
 
@@ -191,7 +191,7 @@ def eq_maker(cls):
     return code, globs
 
 
-def frozen_setattr_maker(cls):
+def frozen_setattr_generator(cls):
     globs = {}
     field_names = set(get_fields(cls))
     flags = get_flags(cls)
@@ -220,7 +220,7 @@ def frozen_setattr_maker(cls):
     return code, globs
 
 
-def frozen_delattr_maker(cls):
+def frozen_delattr_generator(cls):
     body = (
         '    raise TypeError(\n'
         '        f"{type(self).__name__!r} object "\n'
@@ -234,12 +234,12 @@ def frozen_delattr_maker(cls):
 
 # As only the __get__ method refers to the class we can use the same
 # Descriptor instances for every class.
-init_desc = MethodMaker("__init__", init_maker)
-repr_desc = MethodMaker("__repr__", repr_maker)
-eq_desc = MethodMaker("__eq__", eq_maker)
-frozen_setattr_desc = MethodMaker("__setattr__", frozen_setattr_maker)
-frozen_delattr_desc = MethodMaker("__delattr__", frozen_delattr_maker)
-default_methods = frozenset({init_desc, repr_desc, eq_desc})
+init_maker = MethodMaker("__init__", init_generator)
+repr_maker = MethodMaker("__repr__", repr_generator)
+eq_maker = MethodMaker("__eq__", eq_generator)
+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})
 
 
 def builder(cls=None, /, *, gatherer, methods, flags=None):
@@ -248,7 +248,7 @@ def builder(cls=None, /, *, gatherer, methods, flags=None):
 
     :param cls: Class to be analysed and have methods generated
     :param gatherer: Function to gather field information
-    :type gatherer: Callable[[type], dict[str, Field]]
+    :type gatherer: Callable[[type], tuple[dict[str, Field], dict[str, Any]]]
     :param methods: MethodMakers to add to the class
     :type methods: set[MethodMaker]
     :param flags: additional flags to store in the internals dictionary
@@ -267,7 +267,14 @@ def builder(cls=None, /, *, gatherer, methods, flags=None):
     internals = {}
     setattr(cls, INTERNALS_DICT, internals)
 
-    cls_fields = gatherer(cls)
+    cls_fields, modifications = gatherer(cls)
+
+    for name, value in modifications.items():
+        if value is NOTHING:
+            delattr(cls, name)
+        else:
+            setattr(cls, name, value)
+
     internals["local_fields"] = cls_fields
 
     mro = cls.__mro__[:-1]  # skip 'object' base class
@@ -352,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),
@@ -361,17 +379,29 @@ _field_internal = {
     "doc": Field(default=None),
 }
 
-_field_methods = {repr_desc, eq_desc}
+_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_desc, frozen_delattr_desc})
+    _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
@@ -390,6 +420,14 @@ class SlotFields(dict):
 
 
 def make_slot_gatherer(field_type=Field):
+    """
+    Create a new annotation gatherer that will work with `Field` instances
+    of the creators definition.
+
+    :param field_type: The `Field` classes to be used when gathering fields
+    :return: A slot gatherer that will check for and generate Fields of
+             the type field_type.
+    """
     def field_slot_gatherer(cls):
         """
         Gather field information for class generation based on __slots__
@@ -405,11 +443,23 @@ def make_slot_gatherer(field_type=Field):
                 "in order to generate a slotclass"
             )
 
-        cls_annotations = cls.__dict__.get("__annotations__", {})
+        # 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 = {
+            **cls.__dict__.get("__annotations__", {})
+        }
+
         cls_fields = {}
         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:
@@ -421,13 +471,15 @@ def make_slot_gatherer(field_type=Field):
             slot_replacement[k] = attrib.doc
             cls_fields[k] = attrib
 
-        # Replace the SlotAttributes instance with a regular dict
-        # So that help() works
-        setattr(cls, "__slots__", slot_replacement)
+        # Send the modifications to the builder for what should be changed
+        # On the class.
+        # In this case, slots with documentation and new annotations.
+        modifications = {
+            "__slots__": slot_replacement,
+            "__annotations__": cls_annotations,
+        }
 
-        # Update annotations with any types from the slots assignment
-        setattr(cls, "__annotations__", cls_annotations)
-        return cls_fields
+        return cls_fields, modifications
 
     return field_slot_gatherer
 
@@ -483,6 +535,8 @@ def make_annotation_gatherer(field_type=Field, leave_default_values=True):
 
         cls_fields: dict[str, field_type] = {}
 
+        modifications = {}
+
         for k, v in cls_annotations.items():
             # Ignore ClassVar
             if is_classvar(v):
@@ -494,20 +548,21 @@ def make_annotation_gatherer(field_type=Field, leave_default_values=True):
                 if isinstance(attrib, field_type):
                     attrib = field_type.from_field(attrib, type=v)
                     if attrib.default is not NOTHING and leave_default_values:
-                        setattr(cls, k, attrib.default)
+                        modifications[k] = attrib.default
                     else:
-                        delattr(cls, k)
+                        # NOTHING sentinel indicates a value should be removed
+                        modifications[k] = NOTHING
                 else:
                     attrib = field_type(default=attrib, type=v)
                     if not leave_default_values:
-                        delattr(cls, k)
+                        modifications[k] = NOTHING
 
             else:
                 attrib = field_type(type=v)
 
             cls_fields[k] = attrib
 
-        return cls_fields
+        return cls_fields, modifications
 
     return field_annotation_gatherer
 
@@ -569,7 +624,7 @@ def annotationclass(cls=None, /, *, methods=default_methods):
 
 _field_init_desc = MethodMaker(
     funcname="__init__",
-    code_generator=get_init_maker(
+    code_generator=get_init_generator(
         null=_NothingType(),
         extra_code=["self.validate_field()"],
     )
@@ -590,11 +645,11 @@ def fieldclass(cls=None, /, *, frozen=False):
     if not cls:
         return lambda cls_: fieldclass(cls_, frozen=frozen)
 
-    field_methods = {_field_init_desc, repr_desc, eq_desc}
+    field_methods = {_field_init_desc, repr_maker, eq_maker}
 
     # Always freeze when running tests
     if frozen or _UNDER_TESTING:
-        field_methods.update({frozen_setattr_desc, frozen_delattr_desc})
+        field_methods.update({frozen_setattr_maker, frozen_delattr_maker})
 
     cls = builder(
         cls,

ducktools/classbuilder/__init__.pyi

@@ -26,24 +26,24 @@ class MethodMaker:
     def __repr__(self) -> str: ...
     def __get__(self, instance, cls) -> Callable: ...
 
-def get_init_maker(
+def get_init_generator(
     null: _NothingType = NOTHING,
     extra_code: None | list[str] = None
 ) -> Callable[[type], tuple[str, dict[str, typing.Any]]]: ...
 
-def init_maker(cls: type) -> tuple[str, dict[str, typing.Any]]: ...
-def repr_maker(cls: type) -> tuple[str, dict[str, typing.Any]]: ...
-def eq_maker(cls: type) -> tuple[str, dict[str, typing.Any]]: ...
+def init_generator(cls: type) -> tuple[str, dict[str, typing.Any]]: ...
+def repr_generator(cls: type) -> tuple[str, dict[str, typing.Any]]: ...
+def eq_generator(cls: type) -> tuple[str, dict[str, typing.Any]]: ...
 
-def frozen_setattr_maker(cls: type) -> tuple[str, dict[str, typing.Any]]: ...
+def frozen_setattr_generator(cls: type) -> tuple[str, dict[str, typing.Any]]: ...
 
-def frozen_delattr_maker(cls: type) -> tuple[str, dict[str, typing.Any]]: ...
+def frozen_delattr_generator(cls: type) -> tuple[str, dict[str, typing.Any]]: ...
 
-init_desc: MethodMaker
-repr_desc: MethodMaker
-eq_desc: MethodMaker
-frozen_setattr_desc: MethodMaker
-frozen_delattr_desc: MethodMaker
+init_maker: MethodMaker
+repr_maker: MethodMaker
+eq_maker: MethodMaker
+frozen_setattr_maker: MethodMaker
+frozen_delattr_maker: MethodMaker
 default_methods: frozenset[MethodMaker]
 
 _T = typing.TypeVar("_T")
@@ -53,7 +53,7 @@ def builder(
     cls: type[_T],
     /,
     *,
-    gatherer: Callable[[type], dict[str, Field]],
+    gatherer: Callable[[type], tuple[dict[str, Field], dict[str, typing.Any]]],
     methods: frozenset[MethodMaker] | set[MethodMaker],
     flags: dict[str, bool] | None = None,
 ) -> type[_T]: ...
@@ -63,7 +63,7 @@ def builder(
     cls: None = None,
     /,
     *,
-    gatherer: Callable[[type], dict[str, Field]],
+    gatherer: Callable[[type], tuple[dict[str, Field], dict[str, typing.Any]]],
     methods: frozenset[MethodMaker] | set[MethodMaker],
     flags: dict[str, bool] | None = None,
 ) -> Callable[[type[_T]], type[_T]]: ...
@@ -92,12 +92,33 @@ 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):
     ...
 
-def make_slot_gatherer(field_type: type[Field] = Field) -> Callable[[type], dict[str, Field]]: ...
+def make_slot_gatherer(
+        field_type: type[Field] = Field
+) -> Callable[[type], tuple[dict[str, Field], dict[str, typing.Any]]]: ...
 
-def slot_gatherer(cls: type) -> dict[str, Field]:
+def slot_gatherer(cls: type) -> tuple[dict[str, Field], dict[str, typing.Any]]:
     ...
 
 def is_classvar(hint: object) -> bool: ...
@@ -105,9 +126,9 @@ def is_classvar(hint: object) -> bool: ...
 def make_annotation_gatherer(
     field_type: type[Field] = Field,
     leave_default_values: bool = True,
-) -> Callable[[type], dict[str, Field]]: ...
+) -> Callable[[type], tuple[dict[str, Field], dict[str, typing.Any]]]: ...
 
-def annotation_gatherer(cls: type) -> dict[str, Field]: ...
+def annotation_gatherer(cls: type) -> tuple[dict[str, Field], dict[str, typing.Any]]: ...
 
 def check_argument_order(cls: type) -> None: ...
 

ducktools/classbuilder/prefab.py

@@ -30,9 +30,9 @@ 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_desc, frozen_delattr_desc, is_classvar,
+    frozen_setattr_maker, frozen_delattr_maker, is_classvar,
 )
 
 PREFAB_FIELDS = "PREFAB_FIELDS"
@@ -344,13 +344,13 @@ def get_asdict_maker():
     return MethodMaker("as_dict", as_dict_gen)
 
 
-init_desc = get_init_maker()
-prefab_init_desc = get_init_maker(init_name=PREFAB_INIT_FUNC)
-repr_desc = get_repr_maker()
-recursive_repr_desc = get_repr_maker(recursion_safe=True)
-eq_desc = get_eq_maker()
-iter_desc = get_iter_maker()
-asdict_desc = get_asdict_maker()
+init_maker = get_init_maker()
+prefab_init_maker = get_init_maker(init_name=PREFAB_INIT_FUNC)
+repr_maker = get_repr_maker()
+recursive_repr_maker = get_repr_maker(recursion_safe=True)
+eq_maker = get_eq_maker()
+iter_maker = get_iter_maker()
+asdict_maker = get_asdict_maker()
 
 
 # Updated field with additional attributes
@@ -441,6 +441,8 @@ def attribute_gatherer(cls):
 
     cls_attribute_names = cls_attributes.keys()
 
+    cls_modifications = {}
+
     if set(cls_annotation_names).issuperset(set(cls_attribute_names)):
         # replace the classes' attributes dict with one with the correct
         # order from the annotations.
@@ -483,7 +485,7 @@ def attribute_gatherer(cls):
 
                     # Clear the attribute from the class after it has been used
                     # in the definition.
-                    delattr(cls, name)
+                    cls_modifications[name] = NOTHING
                 else:
                     attrib = attribute(**extras)
 
@@ -493,14 +495,14 @@ def attribute_gatherer(cls):
     else:
         for name in cls_attributes.keys():
             attrib = cls_attributes[name]
-            delattr(cls, name)  # clear attrib from class
+            cls_modifications[name] = NOTHING
 
             # Some items can still be annotated.
             if name in cls_annotations:
                 new_attrib = Attribute.from_field(attrib, type=cls_annotations[name])
                 cls_attributes[name] = new_attrib
 
-    return cls_attributes
+    return cls_attributes, cls_modifications
 
 
 # Class Builders
@@ -517,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.
@@ -533,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__
@@ -544,34 +548,38 @@ 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()
 
     if init and "__init__" not in cls_dict:
-        methods.add(init_desc)
+        methods.add(init_maker)
     else:
-        methods.add(prefab_init_desc)
+        methods.add(prefab_init_maker)
 
     if repr and "__repr__" not in cls_dict:
         if recursive_repr:
-            methods.add(recursive_repr_desc)
+            methods.add(recursive_repr_maker)
         else:
-            methods.add(repr_desc)
+            methods.add(repr_maker)
     if eq and "__eq__" not in cls_dict:
-        methods.add(eq_desc)
+        methods.add(eq_maker)
     if iter and "__iter__" not in cls_dict:
-        methods.add(iter_desc)
+        methods.add(iter_maker)
     if frozen:
-        methods.add(frozen_setattr_desc)
-        methods.add(frozen_delattr_desc)
+        methods.add(frozen_setattr_maker)
+        methods.add(frozen_delattr_maker)
     if dict_method:
-        methods.add(asdict_desc)
+        methods.add(asdict_maker)
 
     flags = {
         "kw_only": kw_only,
@@ -768,6 +776,7 @@ def build_prefab(
     frozen=False,
     dict_method=False,
     recursive_repr=False,
+    slots=False,
 ):
     """
     Dynamically construct a (dynamic) prefab.
@@ -788,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,
@@ -806,6 +838,7 @@ def build_prefab(
         frozen=frozen,
         dict_method=dict_method,
         recursive_repr=recursive_repr,
+        gathered_fields=gathered_fields,
     )
 
     return cls
@@ -847,17 +880,17 @@ def as_dict(o):
     :param o: instance of a prefab class
     :return: dictionary of {k: v} from fields
     """
+    cls = type(o)
+    if not hasattr(cls, PREFAB_FIELDS):
+        raise TypeError(f"{o!r} should be a prefab instance, not {cls}")
+
     # Attempt to use the generated method if available
     try:
         return o.as_dict()
     except AttributeError:
         pass
 
-    cls = type(o)
-    try:
-        flds = get_attributes(cls)
-    except AttributeError:
-        raise TypeError(f"inst should be a prefab instance, not {cls}")
+    flds = get_attributes(cls)
 
     return {
         name: getattr(o, name)

ducktools/classbuilder/prefab.pyi

@@ -6,7 +6,7 @@ from collections.abc import Callable
 from . import (
     INTERNALS_DICT, NOTHING,
     Field, MethodMaker, SlotFields as SlotFields,
-    builder, fieldclass, get_flags, get_fields, slot_gatherer
+    builder, fieldclass, get_flags, get_fields, make_slot_gatherer
 )
 
 # noinspection PyUnresolvedReferences
@@ -39,13 +39,13 @@ def get_iter_maker() -> MethodMaker: ...
 def get_asdict_maker() -> MethodMaker: ...
 
 
-init_desc: MethodMaker
-prefab_init_desc: MethodMaker
-repr_desc: MethodMaker
-recursive_repr_desc: MethodMaker
-eq_desc: MethodMaker
-iter_desc: MethodMaker
-asdict_desc: MethodMaker
+init_maker: MethodMaker
+prefab_init_maker: MethodMaker
+repr_maker: MethodMaker
+recursive_repr_maker: MethodMaker
+eq_maker: MethodMaker
+iter_maker: MethodMaker
+asdict_maker: MethodMaker
 
 class Attribute(Field):
     __slots__: dict
@@ -93,9 +93,9 @@ def attribute(
     exclude_field: bool = False,
 ) -> Attribute: ...
 
-def slot_prefab_gatherer(cls: type) -> dict[str, Attribute]: ...
+def slot_prefab_gatherer(cls: type) -> tuple[dict[str, Attribute], dict[str, typing.Any]]: ...
 
-def attribute_gatherer(cls: type) -> dict[str, Attribute]: ...
+def attribute_gatherer(cls: type) -> tuple[dict[str, Attribute], dict[str, typing.Any]]: ...
 
 def _make_prefab(
     cls: type,
@@ -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.4.0.dist-info → ducktools_classbuilder-0.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ducktools-classbuilder
-Version: 0.4.0
+Version: 0.5.1
 Summary: Toolkit for creating class boilerplate generators
 Author: David C Ellis
 License: MIT License
@@ -69,11 +69,12 @@ Install from PyPI with:
 In order to create a class decorator using `ducktools.classbuilder` there are
 a few things you need to prepare.
 
-1. A field gathering function to analyse the class and collect valid `Field`s.
+1. A field gathering function to analyse the class and collect valid `Field`s and provide
+   any modifications that need to be applied to the class attributes.
    * An example `slot_gatherer` is included.
 2. Code generators that can make use of the gathered `Field`s to create magic method
-   source code.
-   * Example `init_maker`, `repr_maker` and `eq_maker` generators are included.
+   source code. To be made into descriptors by `MethodMaker`.
+   * Example `init_generator`, `repr_generator` and `eq_generator` generators are included.
 3. A function that calls the `builder` function to apply both of these steps.
 
 A field gathering function needs to take the original class as an argument and 
@@ -91,25 +92,26 @@ class[^1] where keyword arguments define the names and values for the fields.
 
 Code generator functions need to be converted to descriptors before being used. 
 This is done using the provided `MethodMaker` descriptor class. 
-ex: `init_desc = MethodMaker("__init__", init_maker)`
+ex: `init_maker = MethodMaker("__init__", init_generator)`.
 
 These parts can then be used to make a basic class boilerplate generator by 
 providing them to the `builder` function.
 
 ```python
 from ducktools.classbuilder import (
-    builder, 
-    slot_gatherer, 
-    init_maker, eq_maker, repr_maker,
+    builder,
+    slot_gatherer,
+    init_generator, eq_generator, repr_generator,
     MethodMaker,
 )
 
-init_desc = MethodMaker("__init__", init_maker)
-repr_desc = MethodMaker("__repr__", repr_maker)
-eq_desc = MethodMaker("__eq__", eq_maker)
+init_maker = MethodMaker("__init__", init_generator)
+repr_maker = MethodMaker("__repr__", repr_generator)
+eq_maker = MethodMaker("__eq__", eq_generator)
+
 
 def slotclass(cls):
-    return builder(cls, gatherer=slot_gatherer, methods={init_desc, repr_desc, eq_desc})
+    return builder(cls, gatherer=slot_gatherer, methods={init_maker, repr_maker, eq_maker})
 ```
 
 ## Slot Class Usage ##
@@ -238,9 +240,8 @@ It will copy values provided as the `type` to `Field` into the
 Values provided to `doc` will be placed in the final `__slots__` 
 field so they are present on the class if `help(...)` is called.
 
-A fairly basic `annotations_gatherer` and `annotationclass` are included
-in `extras.py` which can be used to generate classbuilders that rely on 
-annotations.
+A fairly basic `annotations_gatherer` and `annotationclass` are also included
+and can be used to generate classbuilders that rely on annotations.
 
 If you want something with more features you can look at the `prefab.py`
 implementation which provides a 'prebuilt' implementation.

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.4.0.dist-info/RECORD

@@ -1,10 +0,0 @@
-ducktools/classbuilder/__init__.py,sha256=7OkqvfHLSSJylkAeiErgZXB9E-lDUK-rvbu3CRWFSdc,19113
-ducktools/classbuilder/__init__.pyi,sha256=64cp1-zpOh2bUVlwcoTTdaampFINIhdFbFDcleE3N0g,4091
-ducktools/classbuilder/prefab.py,sha256=9K_02AJ3-gLR0Cb0RxKwd2n_cwVtE2mf1TE2n_VNp4o,27947
-ducktools/classbuilder/prefab.pyi,sha256=5MiPuuT4hc-Er4xFfrEkBqz-dCjULYJfTM_c0upa0Dc,3758
-ducktools/classbuilder/py.typed,sha256=la67KBlbjXN-_-DfGNcdOcjYumVpKG_Tkw-8n5dnGB4,8
-ducktools_classbuilder-0.4.0.dist-info/LICENSE.md,sha256=6Thz9Dbw8R4fWInl6sGl8Rj3UnKnRbDwrc6jZerpugQ,1070
-ducktools_classbuilder-0.4.0.dist-info/METADATA,sha256=teRrGNNsVoQJ1jLnzctDVFREtSDq9MVCS9GNZr1S01E,9982
-ducktools_classbuilder-0.4.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-ducktools_classbuilder-0.4.0.dist-info/top_level.txt,sha256=uSDLtio3ZFqdwcsMJ2O5yhjB4Q3ytbBWbA8rJREganc,10
-ducktools_classbuilder-0.4.0.dist-info/RECORD,,