ducktools-classbuilder 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

ducktools/classbuilder/__init__.py

@@ -19,7 +19,7 @@
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
-__version__ = "v0.1.0"
+__version__ = "v0.2.0"
 
 # Change this name if you make heavy modifications
 INTERNALS_DICT = "__classbuilder_internals__"
@@ -34,6 +34,9 @@ def get_internals(cls):
     and 'local_fields' attributes this will always
     evaluate as 'truthy' if this is a generated class.
 
+    Generally you should use the helper get_flags and
+    get_fields methods.
+
     Usage:
        if internals := get_internals(cls):
            ...
@@ -44,15 +47,28 @@ def get_internals(cls):
     return getattr(cls, INTERNALS_DICT, None)
 
 
-def get_fields(cls):
+def get_fields(cls, *, local=False):
     """
     Utility function to gather the fields dictionary
     from the class internals.
 
     :param cls: generated class
+    :param local: get only fields that were not inherited
     :return: dictionary of keys and Field attribute info
     """
-    return getattr(cls, INTERNALS_DICT)["fields"]
+    key = "local_fields" if local else "fields"
+    return getattr(cls, INTERNALS_DICT)[key]
+
+
+def get_flags(cls):
+    """
+    Utility function to gather the flags dictionary
+    from the class internals.
+
+    :param cls: generated class
+    :return: dictionary of keys and flag values
+    """
+    return getattr(cls, INTERNALS_DICT)["flags"]
 
 
 def get_inst_fields(inst):
@@ -106,14 +122,15 @@ class MethodMaker:
         return method.__get__(instance, cls)
 
 
-def init_maker(cls, *, null=NOTHING, kw_only=False):
+def init_maker(cls, *, null=NOTHING):
     fields = get_fields(cls)
+    flags = get_flags(cls)
 
     arglist = []
     assignments = []
     globs = {}
 
-    if kw_only:
+    if flags.get("kw_only", False):
         arglist.append("*")
 
     for k, v in fields.items():
@@ -180,7 +197,7 @@ eq_desc = MethodMaker("__eq__", eq_maker)
 default_methods = frozenset({init_desc, repr_desc, eq_desc})
 
 
-def builder(cls=None, /, *, gatherer, methods):
+def builder(cls=None, /, *, gatherer, methods, flags=None):
     """
     The main builder for class generation
 
@@ -189,6 +206,8 @@ def builder(cls=None, /, *, gatherer, methods):
     :type gatherer: Callable[[type], dict[str, Field]]
     :param methods: MethodMakers to add to the class
     :type methods: set[MethodMaker]
+    :param flags: additional flags to store in the internals dictionary
+                  for use by method generators.
     :return: The modified class (the class itself is modified, but this is expected).
     """
     # Handle `None` to make wrapping with a decorator easier.
@@ -197,6 +216,7 @@ def builder(cls=None, /, *, gatherer, methods):
             cls_,
             gatherer=gatherer,
             methods=methods,
+            flags=flags,
         )
 
     internals = {}
@@ -212,11 +232,12 @@ def builder(cls=None, /, *, gatherer, methods):
         fields = {}
         for c in reversed(mro):
             try:
-                fields.update(get_internals(c)["local_fields"])
+                fields.update(get_fields(c, local=True))
             except AttributeError:
                 pass
 
     internals["fields"] = fields
+    internals["flags"] = flags if flags is not None else {}
 
     # Assign all of the method generators
     for method in methods:
@@ -296,7 +317,8 @@ _field_internal = {
 builder(
     Field,
     gatherer=lambda cls_: _field_internal,
-    methods=frozenset({repr_desc, eq_desc})
+    methods=frozenset({repr_desc, eq_desc}),
+    flags={"slotted": True, "kw_only": True},
 )
 
 
@@ -368,7 +390,7 @@ def slotclass(cls=None, /, *, methods=default_methods, syntax_check=True):
     if not cls:
         return lambda cls_: slotclass(cls_, methods=methods, syntax_check=syntax_check)
 
-    cls = builder(cls, gatherer=slot_gatherer, methods=methods)
+    cls = builder(cls, gatherer=slot_gatherer, methods=methods, flags={"slotted": True})
 
     if syntax_check:
         fields = get_fields(cls)
@@ -398,7 +420,7 @@ def fieldclass(cls):
     # Fields need a way to call their validate method
     # So append it to the code from __init__.
     def field_init_func(cls_):
-        code, globs = init_maker(cls_, null=field_nothing, kw_only=True)
+        code, globs = init_maker(cls_, null=field_nothing)
         code += "    self.validate_field()\n"
         return code, globs
 
@@ -412,7 +434,8 @@ def fieldclass(cls):
     cls = builder(
         cls,
         gatherer=slot_gatherer,
-        methods=field_methods
+        methods=field_methods,
+        flags={"slotted": True, "kw_only": True}
     )
 
-    return cls
+    return cls

ducktools/classbuilder/__init__.pyi

@@ -1,12 +1,16 @@
 import typing
 from collections.abc import Callable
 
+_py_type = type  # Alias for type where it is used as a name
+
 __version__: str
 INTERNALS_DICT: str
 
 def get_internals(cls) -> dict[str, typing.Any] | None: ...
 
-def get_fields(cls: type) -> dict[str, Field]: ...
+def get_fields(cls: type, *, local: bool = False) -> dict[str, Field]: ...
+
+def get_flags(cls:type) -> dict[str, bool]: ...
 
 def get_inst_fields(inst: typing.Any) -> dict[str, typing.Any]: ...
 
@@ -28,7 +32,6 @@ def init_maker(
     cls: type,
     *,
     null: _NothingType = NOTHING,
-    kw_only: bool = False
 ) -> 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]]: ...
@@ -38,14 +41,17 @@ repr_desc: MethodMaker
 eq_desc: MethodMaker
 default_methods: frozenset[MethodMaker]
 
+_T = typing.TypeVar("_T")
+
 @typing.overload
 def builder(
-    cls: type,
+    cls: type[_T],
     /,
     *,
     gatherer: Callable[[type], dict[str, Field]],
-    methods: frozenset[MethodMaker] | set[MethodMaker]
-) -> typing.Any: ...
+    methods: frozenset[MethodMaker] | set[MethodMaker],
+    flags: dict[str, bool] | None = None,
+) -> type[_T]: ...
 
 @typing.overload
 def builder(
@@ -53,36 +59,32 @@ def builder(
     /,
     *,
     gatherer: Callable[[type], dict[str, Field]],
-    methods: frozenset[MethodMaker] | set[MethodMaker]
-) -> Callable[[type], type]: ...
+    methods: frozenset[MethodMaker] | set[MethodMaker],
+    flags: dict[str, bool] | None = None,
+) -> Callable[[type[_T]], type[_T]]: ...
 
 
-_Self = typing.TypeVar("_Self", bound="Field")
-
 class Field:
     default: _NothingType | typing.Any
     default_factory: _NothingType | typing.Any
-    type: _NothingType | type
+    type: _NothingType | _py_type
     doc: None | str
 
+    __classbuilder_internals__: dict
+
     def __init__(
         self,
         *,
         default: _NothingType | typing.Any = NOTHING,
         default_factory: _NothingType | typing.Any = NOTHING,
-        type: _NothingType | type = NOTHING,
+        type: _NothingType | _py_type = NOTHING,
         doc: None | str = None,
     ) -> None: ...
-    @property
-    def _inherited_slots(self) -> list[str]: ...
     def __repr__(self) -> str: ...
-    @typing.overload
-    def __eq__(self, other: _Self) -> bool: ...
-    @typing.overload
-    def __eq__(self, other: object) -> NotImplemented: ...
+    def __eq__(self, other: Field | object) -> bool: ...
     def validate_field(self) -> None: ...
     @classmethod
-    def from_field(cls, fld: Field, **kwargs: typing.Any) -> _Self: ...
+    def from_field(cls, fld: Field, /, **kwargs: typing.Any) -> Field: ...
 
 
 class SlotFields(dict):
@@ -93,19 +95,20 @@ def slot_gatherer(cls: type) -> dict[str, Field]:
 
 @typing.overload
 def slotclass(
-    cls: type,
+    cls: type[_T],
     /,
     *,
     methods: frozenset[MethodMaker] | set[MethodMaker] = default_methods,
     syntax_check: bool = True
-) -> typing.Any: ...
+) -> type[_T]: ...
 
+@typing.overload
 def slotclass(
     cls: None = None,
     /,
     *,
     methods: frozenset[MethodMaker] | set[MethodMaker] = default_methods,
     syntax_check: bool = True
-) -> Callable[[type], type]: ...
+) -> Callable[[type[_T]], type[_T]]: ...
 
-def fieldclass(cls: type) -> typing.Any: ...
+def fieldclass(cls: type[_T]) -> type[_T]: ...

ducktools/classbuilder/prefab.py

@@ -31,7 +31,7 @@ import sys
 from . import (
     INTERNALS_DICT, NOTHING,
     Field, MethodMaker, SlotFields,
-    builder, fieldclass, get_internals, slot_gatherer
+    builder, fieldclass, get_flags, get_fields, slot_gatherer
 )
 
 PREFAB_FIELDS = "PREFAB_FIELDS"
@@ -84,10 +84,11 @@ def get_attributes(cls):
 def get_init_maker(*, init_name="__init__"):
     def __init__(cls: "type") -> "tuple[str, dict]":
         globs = {}
-        internals = get_internals(cls)
         # Get the internals dictionary and prepare attributes
-        attributes = internals["fields"]
-        kw_only = internals["kw_only"]
+        attributes = get_attributes(cls)
+        flags = get_flags(cls)
+
+        kw_only = flags.get("kw_only", False)
 
         # Handle pre/post init first - post_init can change types for __init__
         # Get pre and post init arguments
@@ -319,12 +320,19 @@ def get_eq_maker():
 
 def get_iter_maker():
     def __iter__(cls: "type") -> "tuple[str, dict]":
-        field_names = get_attributes(cls).keys()
+        fields = get_attributes(cls)
 
-        if field_names:
-            values = "\n".join(f"    yield self.{name} " for name in field_names)
-        else:
+        valid_fields = (
+            name for name, attrib in fields.items()
+            if attrib.iter and not attrib.exclude_field
+        )
+
+        values = "\n".join(f"    yield self.{name}" for name in valid_fields)
+
+        # if values is an empty string
+        if not values:
             values = "    yield from ()"
+
         code = f"def __iter__(self):\n{values}"
         globs = {}
         return code, globs
@@ -335,14 +343,16 @@ def get_iter_maker():
 def get_frozen_setattr_maker():
     def __setattr__(cls: "type") -> "tuple[str, dict]":
         globs = {}
-        internals = get_internals(cls)
-        field_names = internals["fields"].keys()
+        attributes = get_attributes(cls)
+        flags = get_flags(cls)
 
         # Make the fields set literal
-        fields_delimited = ", ".join(f"{field!r}" for field in field_names)
+        fields_delimited = ", ".join(f"{field!r}" for field in attributes)
         field_set = f"{{ {fields_delimited} }}"
 
-        if internals["slotted"]:
+        # Better to be safe and use the method that works in both cases
+        # if somehow slotted has not been set.
+        if flags.get("slotted", True):
             globs["__prefab_setattr_func"] = object.__setattr__
             setattr_method = "__prefab_setattr_func(self, name, value)"
         else:
@@ -366,6 +376,7 @@ def get_frozen_setattr_maker():
 
 
 def get_frozen_delattr_maker():
+    # noinspection PyUnusedLocal
     def __delattr__(cls: "type") -> "tuple[str, dict]":
         body = (
             '    raise TypeError(\n'
@@ -415,6 +426,7 @@ class Attribute(Field):
         init=True,
         repr=True,
         compare=True,
+        iter=True,
         kw_only=False,
         in_dict=True,
         exclude_field=False,
@@ -436,6 +448,7 @@ def attribute(
     init=True,
     repr=True,
     compare=True,
+    iter=True,
     kw_only=False,
     in_dict=True,
     exclude_field=False,
@@ -443,8 +456,7 @@ def attribute(
     type=NOTHING,
 ):
     """
-    Additional definition for how to generate standard methods
-    for an instance attribute.
+    Get an object to define a prefab Attribute
 
     :param default: Default value for this attribute
     :param default_factory: 0 argument callable to give a default value
@@ -452,6 +464,7 @@ def attribute(
     :param init: Include this attribute in the __init__ parameters
     :param repr: Include this attribute in the class __repr__
     :param compare: Include this attribute in the class __eq__
+    :param iter: Include this attribute in the class __iter__ if generated
     :param kw_only: Make this argument keyword only in init
     :param in_dict: Include this attribute in methods that serialise to dict
     :param exclude_field: Exclude this field from all magic method generation
@@ -469,6 +482,7 @@ def attribute(
         init=init,
         repr=repr,
         compare=compare,
+        iter=iter,
         kw_only=kw_only,
         in_dict=in_dict,
         exclude_field=exclude_field,
@@ -477,6 +491,14 @@ def attribute(
     )
 
 
+def slot_prefab_gatherer(cls):
+    # For prefabs it's easier if everything is an attribute
+    return {
+        name: Attribute.from_field(fld)
+        for name, fld in slot_gatherer(cls).items()
+    }
+
+
 # Gatherer for classes built on attributes or annotations
 def attribute_gatherer(cls):
     cls_annotations = cls.__dict__.get("__annotations__", {})
@@ -588,7 +610,7 @@ def _make_prefab(
 
     slots = cls_dict.get("__slots__")
     if isinstance(slots, SlotFields):
-        gatherer = slot_gatherer
+        gatherer = slot_prefab_gatherer
         slotted = True
     else:
         gatherer = attribute_gatherer
@@ -616,18 +638,20 @@ def _make_prefab(
     if dict_method:
         methods.add(asdict_desc)
 
+    flags = {
+        "kw_only": kw_only,
+        "slotted": slotted,
+    }
+
     cls = builder(
         cls,
         gatherer=gatherer,
         methods=methods,
+        flags=flags,
     )
 
-    # Add fields not covered by builder
-    internals = get_internals(cls)
-    internals["slotted"] = slotted
-    internals["kw_only"] = kw_only
-    fields = internals["fields"]
-    local_fields = internals["local_fields"]
+    # Get fields now the class has been built
+    fields = get_fields(cls)
 
     # Check pre_init and post_init functions if they exist
     try:
@@ -699,14 +723,12 @@ def _make_prefab(
         if not isinstance(attrib, Attribute):
             attrib = Attribute.from_field(attrib)
             fields[name] = attrib
-            if name in local_fields:
-                local_fields[name] = attrib
 
         # Excluded fields *MUST* be forwarded to post_init
         if attrib.exclude_field:
             if name not in post_init_args:
                 raise PrefabError(
-                    f"{name} is an excluded attribute but is not passed to post_init"
+                    f"{name!r} is an excluded attribute but is not passed to post_init"
                 )
         else:
             valid_args.append(name)

ducktools/classbuilder/prefab.pyi

@@ -1,4 +1,6 @@
 import typing
+from typing_extensions import dataclass_transform
+
 from collections.abc import Callable
 
 from . import (
@@ -7,6 +9,9 @@ from . import (
     builder, fieldclass, get_internals, slot_gatherer
 )
 
+# noinspection PyUnresolvedReferences
+from . import _NothingType
+
 PREFAB_FIELDS: str
 PREFAB_INIT_FUNC: str
 PRE_INIT_FUNC: str
@@ -56,6 +61,7 @@ class Attribute(Field):
     init: bool
     repr: bool
     compare: bool
+    iter: bool
     kw_only: bool
     in_dict: bool
     exclude_field: bool
@@ -63,39 +69,40 @@ class Attribute(Field):
     def __init__(
         self,
         *,
-        default: typing.Any | NOTHING =NOTHING,
-        default_factory: typing.Any | NOTHING = NOTHING,
-        type: type | NOTHING = NOTHING,
+        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,
+        iter: bool = True,
         kw_only: bool = False,
         in_dict: bool = True,
         exclude_field: bool = False,
     ) -> None: ...
 
     def __repr__(self) -> str: ...
-    @typing.overload
-    def __eq__(self, other: Attribute) -> bool: ...
-    def __eq__(self, other: object) -> NotImplemented: ...
-
+    def __eq__(self, other: Attribute | object) -> bool: ...
     def validate_field(self) -> None: ...
 
 def attribute(
     *,
-    default: typing.Any | NOTHING = NOTHING,
-    default_factory: typing.Any | NOTHING = NOTHING,
-    type: type | NOTHING = NOTHING,
+    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,
+    iter: bool = True,
     kw_only: bool = False,
     in_dict: bool = True,
     exclude_field: bool = False,
 ) -> Attribute: ...
 
+def slot_prefab_gatherer(cls: type) -> dict[str, Attribute]: ...
+
 def attribute_gatherer(cls: type) -> dict[str, Attribute]: ...
 
 def _make_prefab(
@@ -112,9 +119,14 @@ def _make_prefab(
     recursive_repr: bool = False,
 ) -> type: ...
 
-@typing.dataclass_transform
+_T = typing.TypeVar("_T")
+
+
+# For some reason PyCharm can't see 'attribute'?!?
+# noinspection PyUnresolvedReferences
+@dataclass_transform(field_specifiers=(Attribute, attribute))
 def prefab(
-    cls: type | None = None,
+    cls: type[_T] | None = None,
     *,
     init: bool = True,
     repr: bool = True,
@@ -125,7 +137,7 @@ def prefab(
     frozen: bool = False,
     dict_method: bool = False,
     recursive_repr: bool = False,
-) -> type | Callable[[type], type]: ...
+) -> type[_T] | Callable[[type[_T]], type[_T]]: ...
 
 def build_prefab(
     class_name: str,

{ducktools_classbuilder-0.1.0.dist-info → ducktools_classbuilder-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ducktools-classbuilder
-Version: 0.1.0
+Version: 0.2.0
 Summary: Toolkit for creating class boilerplate generators
 Author: David C Ellis
 License: MIT License
@@ -44,6 +44,7 @@ Requires-Dist: sphinx-rtd-theme ; extra == 'docs'
 Provides-Extra: testing
 Requires-Dist: pytest ; extra == 'testing'
 Requires-Dist: pytest-cov ; extra == 'testing'
+Requires-Dist: mypy ; extra == 'testing'
 
 # Ducktools: Class Builder #
 
@@ -53,19 +54,74 @@ of writing... functions... that will bring back the **joy** of writing classes.
 Maybe.
 
 While `attrs` and `dataclasses` are class boilerplate generators, 
-`ducktools.classbuilder` is intended to be a dataclasses-like generator.
+`ducktools.classbuilder` is intended to be a `@dataclass`-like generator.
 The goal is to handle some of the basic functions and to allow for flexible
 customization of both the field collection and the method generation.
 
 `ducktools.classbuilder.prefab` includes a prebuilt implementation using these tools.
 
+Install from PyPI with:
+`python -m pip install ducktools-classbuilder`
+
+## Usage: building a class decorator ##
+
+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.
+   * 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.
+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 
+return a dictionary of `{key: Field(...)}` pairs.
+
+> [!NOTE]
+> The `builder` will handle inheritance so do not collect fields from parent classes.
+
+The code generators take the class as the only argument and return a tuple 
+of method source code and globals to be provided to `exec(code, globs)` in order 
+to generate the actual method. 
+
+The provided `slot_gatherer` looks for `__slots__` being assigned a `SlotFields` 
+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)`
+
+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,
+    MethodMaker,
+)
+
+init_desc = MethodMaker("__init__", init_maker)
+repr_desc = MethodMaker("__repr__", repr_maker)
+eq_desc = MethodMaker("__eq__", eq_maker)
+
+def slotclass(cls):
+    return builder(cls, gatherer=slot_gatherer, methods={init_desc, repr_desc, eq_desc})
+```
+
 ## Slot Class Usage ##
 
-The building toolkit also includes a basic implementation that uses
-`__slots__` to define the fields by assigning a `SlotFields` instance.
+This created `slotclass` function can then be used as a decorator to generate classes in 
+a similar manner to the `@dataclass` decorator from `dataclasses`. 
+
+> [!NOTE] 
+> `ducktools.classbuilder` includes a premade version of `slotclass` that can
+> be used directly. (The included version has some extra features).
 
 ```python
-from ducktools.classbuilder import slotclass, Field, SlotFields
+from ducktools.classbuilder import Field, SlotFields
 
 @slotclass
 class SlottedDC:
@@ -81,28 +137,36 @@ ex = SlottedDC()
 print(ex)
 ```
 
-## Why does the basic implementation use slots? ##
+> [!TIP]
+> For more information and examples of creating class generators with additional 
+> features using the builder see 
+> [the docs](https://ducktools-classbuilder.readthedocs.io/en/latest/extension_examples.html)
+
+## Why does your example use `__slots__` instead of annotations? ##
 
-Dataclasses has a problem when you use `@dataclass(slots=True)`, 
-although this is not unique to dataclasses but inherent to the way both
-`__slots__` and decorators work.
+If you want to use `__slots__` in order to save memory you have to declare
+them when the class is originally created as you can't add them later.
 
-In order for this to *appear* to work, dataclasses has to make a new class 
-and attempt to copy over everything from the original. This is because 
-decorators operate on classes *after they have been created* while slots 
-need to be declared beforehand. While you can change the value of `__slots__` 
-after a class has been created, this will have no effect on the internal
-structure of the class.
+When you use `@dataclass(slots=True)`[^2] with `dataclasses` in order for 
+this to work, `dataclasses` has to make a new class and attempt to
+copy over everything from the original. 
+This is because decorators operate on classes *after they have been created* 
+while slots need to be declared beforehand. 
+While you can change the value of `__slots__` after a class has been created, 
+this will have no effect on the internal structure of the class.
 
 By declaring the class using `__slots__` on the other hand, we can take
 advantage of the fact that it accepts a mapping, where the keys will be
 used as the attributes to create as slots. The values can then be used as
-the default values equivalently to how type hints are used in dataclasses.
+the default values equivalently to how type hints are used in `dataclasses`.
 
-For example these two classes would be roughly equivalent, except 
+For example these two classes would be roughly equivalent, except that
 `@dataclass` has had to recreate the class from scratch while `@slotclass`
-has simply added the methods on to the original class. This is easy to 
-demonstrate using another decorator.
+has added the methods on to the original class. 
+This means that any references stored to the original class *before*
+`@dataclass` has rebuilt the class will not be pointing towards the 
+correct class. 
+This can be demonstrated using a simple class register decorator.
 
 > This example requires Python 3.10 as earlier versions of 
 > `dataclasses` did not support the `slots` argument.
@@ -140,7 +204,6 @@ print(SlotCoords())
 
 print(f"{DataCoords is class_register[DataCoords.__name__] = }")
 print(f"{SlotCoords is class_register[SlotCoords.__name__] = }")
-
 ```
 
 ## What features does this have? ##
@@ -158,9 +221,6 @@ field so they are present on the class if `help(...)` is called.
 If you want something with more features you can look at the `prefab.py`
 implementation which provides a 'prebuilt' implementation.
 
-For more information on creating class generators using the builder
-see [the docs](https://ducktools-classbuilder.readthedocs.io/en/latest/extension_examples.html)
-
 ## Will you add \<feature\> to `classbuilder.prefab`? ##
 
 No. Not unless it's something I need or find interesting.
@@ -177,3 +237,9 @@ with a specific feature, you can create or add it yourself.
 ## Credit ##
 
 Heavily inspired by [David Beazley's Cluegen](https://github.com/dabeaz/cluegen)
+
+[^1]: `SlotFields` is actually just a subclassed `dict` with no changes. `__slots__`
+      works with dictionaries using the values of the keys, while fields are normally
+      used for documentation.
+
+[^2]: or `@attrs.define`.

ducktools_classbuilder-0.2.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+ducktools/classbuilder/__init__.py,sha256=OOVk-E6UBi8-68bEy9pqCiKbn9oQ1y4tRGnZ3LGsGYg,13747
+ducktools/classbuilder/__init__.pyi,sha256=-QHJhPn4EjI4XW4OI74MKNg2tGKJiM3w0ELSOvPstAw,2877
+ducktools/classbuilder/prefab.py,sha256=yUa_yoPKU1hzI4klqWJOwTZEXtNOmUU1fQnLuHkVACw,29871
+ducktools/classbuilder/prefab.pyi,sha256=4cyXYqTXtCJv4gPOSNtkBrjORj2jt1bvX6p_sCOzoXw,3963
+ducktools/classbuilder/py.typed,sha256=la67KBlbjXN-_-DfGNcdOcjYumVpKG_Tkw-8n5dnGB4,8
+ducktools_classbuilder-0.2.0.dist-info/LICENSE.md,sha256=6Thz9Dbw8R4fWInl6sGl8Rj3UnKnRbDwrc6jZerpugQ,1070
+ducktools_classbuilder-0.2.0.dist-info/METADATA,sha256=LmHMIhj4jJ9WlmHOac4lBVgW4l6cdNUjG8cEvIULVko,9280
+ducktools_classbuilder-0.2.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+ducktools_classbuilder-0.2.0.dist-info/top_level.txt,sha256=uSDLtio3ZFqdwcsMJ2O5yhjB4Q3ytbBWbA8rJREganc,10
+ducktools_classbuilder-0.2.0.dist-info/RECORD,,

ducktools_classbuilder-0.1.0.dist-info/RECORD

@@ -1,10 +0,0 @@
-ducktools/classbuilder/__init__.py,sha256=oEdcQdMEqaQjUfbPkHpe55iCiPssDQxf4zxoAMdsTt8,12950
-ducktools/classbuilder/__init__.pyi,sha256=BlpHmxIL4dAiVKgqElRR3wVs7aw73qyJRaSvr-Tuyc0,2770
-ducktools/classbuilder/prefab.py,sha256=qQJzN4ys6Av6s9NaabzSqRKE5BXDfhidt3EtGZ0HAxQ,29405
-ducktools/classbuilder/prefab.pyi,sha256=wrq8NKwy9TsQ6fpnMyTf4DaGtCOK_90NHeU61CfNOo4,3589
-ducktools/classbuilder/py.typed,sha256=la67KBlbjXN-_-DfGNcdOcjYumVpKG_Tkw-8n5dnGB4,8
-ducktools_classbuilder-0.1.0.dist-info/LICENSE.md,sha256=6Thz9Dbw8R4fWInl6sGl8Rj3UnKnRbDwrc6jZerpugQ,1070
-ducktools_classbuilder-0.1.0.dist-info/METADATA,sha256=FHgeLZx-RfcvY2ty1l6O19z449So-UQZIcBinJ8n5xU,6675
-ducktools_classbuilder-0.1.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-ducktools_classbuilder-0.1.0.dist-info/top_level.txt,sha256=uSDLtio3ZFqdwcsMJ2O5yhjB4Q3ytbBWbA8rJREganc,10
-ducktools_classbuilder-0.1.0.dist-info/RECORD,,