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

{ducktools_classbuilder-0.7.5 → ducktools_classbuilder-0.8.1}/MANIFEST.in

@@ -5,5 +5,6 @@ graft docs
 prune */build
 prune */dist
 prune */.pytest_cache
+prune perf
 
 global-exclude *~ *.py[cod] *.so

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

@@ -1,30 +1,8 @@
 Metadata-Version: 2.1
 Name: ducktools-classbuilder
-Version: 0.7.5
+Version: 0.8.1
 Summary: Toolkit for creating class boilerplate generators
 Author: David C Ellis
-License: MIT License
-        
-        Copyright (c) 2024 David C Ellis
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        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.
-        
 Project-URL: Homepage, https://github.com/davidcellis/ducktools-classbuilder
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python :: 3.8
@@ -37,7 +15,7 @@ Classifier: Operating System :: OS Independent
 Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-License-File: LICENSE.md
+License-File: LICENSE
 Provides-Extra: testing
 Requires-Dist: pytest>=8.2; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
@@ -86,10 +64,12 @@ These tools are available from the main `ducktools.classbuilder` module.
 * `@slotclass`
   * A decorator based implementation that uses a special dict subclass assigned
      to `__slots__` to describe the fields for method generation.
-* `AnnotationClass`
-  * A subclass based implementation that works with `__slots__`, type annotations
-    or `Field(...)` attributes to describe the fields for method generation.
-  * If `__slots__` isn't used to declare fields, it will be generated by a metaclass.
+* `SlotMakerMeta`
+  * A metaclass for creating other implementations using annotations, fields or slots.
+  * This metaclass will allow for creating `__slots__` correctly in subclasses.
+* `builder`
+  * This is the main tool used for constructing decorators and base classes to provide
+    generated methods.
 
 Each of these forms of class generation will result in the same methods being 
 attached to the class after the field information has been obtained.
@@ -119,8 +99,9 @@ This includes more customization including `__prefab_pre_init__` and `__prefab_p
 functions for subclass customization.
 
 A `@prefab` decorator and `Prefab` base class are provided. 
-Similar to `AnnotationClass`, `Prefab` will generate `__slots__` by default.
-However decorated classes with `@prefab` that do not declare fields using `__slots__`
+
+`Prefab` will generate `__slots__` by default.
+decorated classes with `@prefab` that do not declare fields using `__slots__`
 will **not** be slotted and there is no `slots` argument to apply this.
 
 Here is an example of applying a conversion in `__post_init__`:
@@ -164,7 +145,7 @@ the fields can be set *before* the class is constructed, so the class
 will work correctly without needing to be rebuilt.
 
 For example these two classes would be roughly equivalent, except that
-`@dataclass` has had to recreate the class from scratch while `AnnotationClass`
+`@dataclass` has had to recreate the class from scratch while `Prefab`
 has created `__slots__` and 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 
@@ -179,7 +160,7 @@ functions.
 ```python
 import json
 from dataclasses import dataclass
-from ducktools.classbuilder import AnnotationClass, Field
+from ducktools.classbuilder.prefab import Prefab, attribute
 
 
 class _RegisterDescriptor:
@@ -222,10 +203,10 @@ class DataCoords:
         return {"x": self.x, "y": self.y}
 
 
-# slots=True is the default for AnnotationClass
-class BuilderCoords(AnnotationClass, slots=True):
+# slots=True is the default for Prefab
+class BuilderCoords(Prefab):
     x: float = 0.0
-    y: float = Field(default=0.0, doc="y coordinate")
+    y: float = attribute(default=0.0, doc="y coordinate")
 
     @register.register_method
     def to_json(self):
@@ -289,9 +270,6 @@ 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.
 
-`AnnotationClass` offers the same features with additional methods of gathering
-fields.
-
 If you want something with more features you can look at the `prefab`
 submodule which provides more specific features that differ further from the 
 behaviour of `dataclasses`.

{ducktools_classbuilder-0.7.5 → ducktools_classbuilder-0.8.1}/README.md

@@ -32,10 +32,12 @@ These tools are available from the main `ducktools.classbuilder` module.
 * `@slotclass`
   * A decorator based implementation that uses a special dict subclass assigned
      to `__slots__` to describe the fields for method generation.
-* `AnnotationClass`
-  * A subclass based implementation that works with `__slots__`, type annotations
-    or `Field(...)` attributes to describe the fields for method generation.
-  * If `__slots__` isn't used to declare fields, it will be generated by a metaclass.
+* `SlotMakerMeta`
+  * A metaclass for creating other implementations using annotations, fields or slots.
+  * This metaclass will allow for creating `__slots__` correctly in subclasses.
+* `builder`
+  * This is the main tool used for constructing decorators and base classes to provide
+    generated methods.
 
 Each of these forms of class generation will result in the same methods being 
 attached to the class after the field information has been obtained.
@@ -65,8 +67,9 @@ This includes more customization including `__prefab_pre_init__` and `__prefab_p
 functions for subclass customization.
 
 A `@prefab` decorator and `Prefab` base class are provided. 
-Similar to `AnnotationClass`, `Prefab` will generate `__slots__` by default.
-However decorated classes with `@prefab` that do not declare fields using `__slots__`
+
+`Prefab` will generate `__slots__` by default.
+decorated classes with `@prefab` that do not declare fields using `__slots__`
 will **not** be slotted and there is no `slots` argument to apply this.
 
 Here is an example of applying a conversion in `__post_init__`:
@@ -110,7 +113,7 @@ the fields can be set *before* the class is constructed, so the class
 will work correctly without needing to be rebuilt.
 
 For example these two classes would be roughly equivalent, except that
-`@dataclass` has had to recreate the class from scratch while `AnnotationClass`
+`@dataclass` has had to recreate the class from scratch while `Prefab`
 has created `__slots__` and 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 
@@ -125,7 +128,7 @@ functions.
 ```python
 import json
 from dataclasses import dataclass
-from ducktools.classbuilder import AnnotationClass, Field
+from ducktools.classbuilder.prefab import Prefab, attribute
 
 
 class _RegisterDescriptor:
@@ -168,10 +171,10 @@ class DataCoords:
         return {"x": self.x, "y": self.y}
 
 
-# slots=True is the default for AnnotationClass
-class BuilderCoords(AnnotationClass, slots=True):
+# slots=True is the default for Prefab
+class BuilderCoords(Prefab):
     x: float = 0.0
-    y: float = Field(default=0.0, doc="y coordinate")
+    y: float = attribute(default=0.0, doc="y coordinate")
 
     @register.register_method
     def to_json(self):
@@ -235,9 +238,6 @@ 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.
 
-`AnnotationClass` offers the same features with additional methods of gathering
-fields.
-
 If you want something with more features you can look at the `prefab`
 submodule which provides more specific features that differ further from the 
 behaviour of `dataclasses`.

{ducktools_classbuilder-0.7.5 → ducktools_classbuilder-0.8.1}/docs/api.md

@@ -40,7 +40,3 @@
 ```{eval-rst}
 .. autofunction:: ducktools.classbuilder.annotations::make_annotation_gatherer
 ```
-
-```{eval-rst}
-.. autoclass:: ducktools.classbuilder.annotations::AnnotationClass
-```

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

@@ -469,7 +469,8 @@ To implement this you need to create a new annotated_gatherer function.
 >       If you need to change the value of a field use Field.from_field(...) to make a new instance.
 
 ```python
-from __future__ import annotations
+# Don't use __future__ annotations with get_ns_annotations in this case 
+# as it doesn't evaluate string annotations.
 
 import types
 from typing import Annotated, Any, ClassVar, get_origin

{ducktools_classbuilder-0.7.5 → ducktools_classbuilder-0.8.1}/docs/generated_code.md

@@ -7,11 +7,14 @@ There is a helper function `get_methods` that can be used to obtain the names an
 methods that have been attached to the class by the builder.
 
 ```python
-from ducktools.classbuilder import AnnotationClass, get_methods
+from ducktools.classbuilder import SlotFields, get_methods, slotclass
 
-class Example(AnnotationClass):
-    a: str = "a"
-    b: str = "b"
+@slotclass
+class Example:
+    __slots__ = SlotFields(
+        a='a',
+        b='b'
+    )
 
 print(get_methods(Example))
 ```
@@ -28,12 +31,15 @@ These can then be used to examine the generated source code and global variables
 to the `exec` function. This can be useful for debugging code generators.
 
 ```python
-from ducktools.classbuilder import AnnotationClass, get_methods
-
-class Example(AnnotationClass):
-    a: str = "a"
-    b: str = "b"
-
+from ducktools.classbuilder import SlotFields, get_methods, slotclass
+
+@slotclass
+class Example:
+    __slots__ = SlotFields(
+        a='a',
+        b='b',
+    )
+    
 methods = get_methods(Example)
 
 for method in methods.values():

{ducktools_classbuilder-0.7.5 → ducktools_classbuilder-0.8.1}/docs/index.md

@@ -65,21 +65,49 @@ ex = SlottedDC()
 print(ex)
 ```
 
-## Annotation Class Usage ##
+## Using Annotations ##
 
-There is an additional AnnotationClass base class that allows creating slotted classes
-using annotations. This has to be a base class with a specific metaclass in order to 
-create the `__slots__` field *before* the class has been generated in order to work
-correctly.
+It is possible to create slotted classes using Annotations.
+There is a `Prefab` base class in the `prefab` submodule that does this,
+but it also easy to implement using the provided tools.
+
+In order to correctly implement `__slots__` this needs to be done
+using a metaclass as `__slots__` must be defined before the **class**
+is created.
 
 ```python
-from ducktools.classbuilder import AnnotationClass
+from ducktools.classbuilder import (
+    SlotMakerMeta,
+    builder,
+    check_argument_order,
+    default_methods,
+    unified_gatherer,
+)
+
+
+class AnnotationClass(metaclass=SlotMakerMeta):
+    __slots__ = {}
+
+    def __init_subclass__(
+            cls,
+            methods=default_methods,
+            gatherer=unified_gatherer,
+            **kwargs
+    ):
+        # Check class dict otherwise this will always be True as this base
+        # class uses slots.
+        slots = "__slots__" in cls.__dict__
+
+        builder(cls, gatherer=gatherer, methods=methods, flags={"slotted": slots})
+        check_argument_order(cls)
+        super().__init_subclass__(**kwargs)
+
 
 class AnnotatedDC(AnnotationClass):
     the_answer: int = 42
     the_question: str = "What do you get if you multiply six by nine?"
 
-    
+
 ex = AnnotatedDC()
 print(ex)
 ```

{ducktools_classbuilder-0.7.5 → ducktools_classbuilder-0.8.1}/docs/tutorial.md

@@ -146,9 +146,15 @@ def report_generator(cls, funcname="report"):
 report_maker = dtbuild.MethodMaker("report", report_generator)
 ```
 
-We can take a quick look at what this generates by applying it to an `AnnotationClass`:
+We can take a quick look at what this generates by applying it to a `slotclass`:
 ```python
-class CodegenDemo(dtbuild.AnnotationClass):
+@dtbuild.slotclass
+class CodegenDemo:
+    __slots__ = dtbuild.SlotFields(
+        field_1="Field one",
+        field_2="Field two",
+        field_3="Field three",       
+    )
     field_1: str = "Field one"
     field_2: str = "Field two"
     field_3: str = "Field three"

{ducktools_classbuilder-0.7.5 → ducktools_classbuilder-0.8.1}/docs_code/docs_ex9_annotated.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 import types
 from typing import Annotated, Any, ClassVar, get_origin
 

ducktools_classbuilder-0.8.1/docs_code/index_example.py

@@ -0,0 +1,34 @@
+from ducktools.classbuilder import (
+    SlotMakerMeta,
+    builder,
+    check_argument_order,
+    default_methods,
+    unified_gatherer,
+)
+
+
+class AnnotationClass(metaclass=SlotMakerMeta):
+    __slots__ = {}
+
+    def __init_subclass__(
+            cls,
+            methods=default_methods,
+            gatherer=unified_gatherer,
+            **kwargs
+    ):
+        # Check class dict otherwise this will always be True as this base
+        # class uses slots.
+        slots = "__slots__" in cls.__dict__
+
+        builder(cls, gatherer=gatherer, methods=methods, flags={"slotted": slots})
+        check_argument_order(cls)
+        super().__init_subclass__(**kwargs)
+
+
+class AnnotatedDC(AnnotationClass):
+    the_answer: int = 42
+    the_question: str = "What do you get if you multiply six by nine?"
+
+
+ex = AnnotatedDC()
+print(ex)

{ducktools_classbuilder-0.7.5 → ducktools_classbuilder-0.8.1}/docs_code/tutorial_code.py

@@ -81,10 +81,13 @@ report_maker = dtbuild.MethodMaker("report", report_generator)
 
 
 # View the generated code by testing on a demo class
-class CodegenDemo(dtbuild.AnnotationClass):
-    field_1: str = "Field one"
-    field_2: str = "Field two"
-    field_3: str = "Field three"
+@dtbuild.slotclass
+class CodegenDemo:
+    __slots__ = dtbuild.SlotFields(
+        field_1="Field one",
+        field_2="Field two",
+        field_3="Field three",
+    )
 
 
 print(report_generator(CodegenDemo).source_code)

{ducktools_classbuilder-0.7.5 → ducktools_classbuilder-0.8.1}/pyproject.toml

@@ -25,7 +25,6 @@ classifiers = [
     "License :: OSI Approved :: MIT License",
 ]
 dynamic = ['version']
-license = {file = "LICENSE.md"}
 
 [project.optional-dependencies]
 testing = ["pytest>=8.2", "pytest-cov", "typing_extensions"]

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

@@ -769,7 +769,7 @@ def make_annotation_gatherer(
             if is_classvar(v):
                 continue
 
-            if v is KW_ONLY:
+            if v is KW_ONLY or (isinstance(v, str) and v == "KW_ONLY"):
                 if kw_flag:
                     raise SyntaxError("KW_ONLY sentinel may only appear once.")
                 kw_flag = True
@@ -868,7 +868,7 @@ def make_unified_gatherer(
         # 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, eval_str=False)
+        cls_annotations = get_ns_annotations(cls_dict)
         cls_attributes = {
             k: v for k, v in cls_dict.items() if isinstance(v, field_type)
         }

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

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

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

@@ -0,0 +1,91 @@
+# MIT License
+#
+# Copyright (c) 2024 David C Ellis
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# 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.
+import sys
+
+
+def get_ns_annotations(ns):
+    """
+    Given a class namespace, attempt to retrieve the
+    annotations dictionary.
+
+    :param ns: Class namespace (eg cls.__dict__)
+    :return: dictionary of annotations
+    """
+
+    annotations = ns.get("__annotations__")
+    if annotations is not None:
+        annotations = annotations.copy()
+    else:
+        # 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)
+
+    if annotations is None:
+        annotations = {}
+
+    return annotations
+
+
+def is_classvar(hint):
+    if isinstance(hint, str):
+        # String annotations, just check if the string 'ClassVar' is in there
+        # This is overly broad and could be smarter.
+        return "ClassVar" in hint
+    elif (annotationlib := sys.modules.get("annotationlib")) and isinstance(hint, annotationlib.ForwardRef):
+        return "ClassVar" in hint.__arg__
+    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
+
+            if _Annotated and _get_origin(hint) is _Annotated:
+                hint = getattr(hint, "__origin__", None)
+
+            if (
+                hint is _typing.ClassVar
+                or getattr(hint, "__origin__", None) is _typing.ClassVar
+            ):
+                return True
+    return False
+

ducktools_classbuilder-0.8.1/src/ducktools/classbuilder/annotations.pyi

@@ -0,0 +1,12 @@
+import typing
+import types
+
+_CopiableMappings = dict[str, typing.Any] | types.MappingProxyType[str, typing.Any]
+
+def get_ns_annotations(
+    ns: _CopiableMappings,
+) -> dict[str, typing.Any]: ...
+
+def is_classvar(
+    hint: object,
+) -> bool: ...

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

@@ -1,30 +1,8 @@
 Metadata-Version: 2.1
 Name: ducktools-classbuilder
-Version: 0.7.5
+Version: 0.8.1
 Summary: Toolkit for creating class boilerplate generators
 Author: David C Ellis
-License: MIT License
-        
-        Copyright (c) 2024 David C Ellis
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        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.
-        
 Project-URL: Homepage, https://github.com/davidcellis/ducktools-classbuilder
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python :: 3.8
@@ -37,7 +15,7 @@ Classifier: Operating System :: OS Independent
 Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-License-File: LICENSE.md
+License-File: LICENSE
 Provides-Extra: testing
 Requires-Dist: pytest>=8.2; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
@@ -86,10 +64,12 @@ These tools are available from the main `ducktools.classbuilder` module.
 * `@slotclass`
   * A decorator based implementation that uses a special dict subclass assigned
      to `__slots__` to describe the fields for method generation.
-* `AnnotationClass`
-  * A subclass based implementation that works with `__slots__`, type annotations
-    or `Field(...)` attributes to describe the fields for method generation.
-  * If `__slots__` isn't used to declare fields, it will be generated by a metaclass.
+* `SlotMakerMeta`
+  * A metaclass for creating other implementations using annotations, fields or slots.
+  * This metaclass will allow for creating `__slots__` correctly in subclasses.
+* `builder`
+  * This is the main tool used for constructing decorators and base classes to provide
+    generated methods.
 
 Each of these forms of class generation will result in the same methods being 
 attached to the class after the field information has been obtained.
@@ -119,8 +99,9 @@ This includes more customization including `__prefab_pre_init__` and `__prefab_p
 functions for subclass customization.
 
 A `@prefab` decorator and `Prefab` base class are provided. 
-Similar to `AnnotationClass`, `Prefab` will generate `__slots__` by default.
-However decorated classes with `@prefab` that do not declare fields using `__slots__`
+
+`Prefab` will generate `__slots__` by default.
+decorated classes with `@prefab` that do not declare fields using `__slots__`
 will **not** be slotted and there is no `slots` argument to apply this.
 
 Here is an example of applying a conversion in `__post_init__`:
@@ -164,7 +145,7 @@ the fields can be set *before* the class is constructed, so the class
 will work correctly without needing to be rebuilt.
 
 For example these two classes would be roughly equivalent, except that
-`@dataclass` has had to recreate the class from scratch while `AnnotationClass`
+`@dataclass` has had to recreate the class from scratch while `Prefab`
 has created `__slots__` and 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 
@@ -179,7 +160,7 @@ functions.
 ```python
 import json
 from dataclasses import dataclass
-from ducktools.classbuilder import AnnotationClass, Field
+from ducktools.classbuilder.prefab import Prefab, attribute
 
 
 class _RegisterDescriptor:
@@ -222,10 +203,10 @@ class DataCoords:
         return {"x": self.x, "y": self.y}
 
 
-# slots=True is the default for AnnotationClass
-class BuilderCoords(AnnotationClass, slots=True):
+# slots=True is the default for Prefab
+class BuilderCoords(Prefab):
     x: float = 0.0
-    y: float = Field(default=0.0, doc="y coordinate")
+    y: float = attribute(default=0.0, doc="y coordinate")
 
     @register.register_method
     def to_json(self):
@@ -289,9 +270,6 @@ 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.
 
-`AnnotationClass` offers the same features with additional methods of gathering
-fields.
-
 If you want something with more features you can look at the `prefab`
 submodule which provides more specific features that differ further from the 
 behaviour of `dataclasses`.

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

@@ -1,6 +1,6 @@
 .gitignore
 .readthedocs.yaml
-LICENSE.md
+LICENSE
 MANIFEST.in
 README.md
 pyproject.toml
@@ -27,11 +27,8 @@ docs_code/docs_ex5_frozen.py
 docs_code/docs_ex7_posonly.py
 docs_code/docs_ex8_converters.py
 docs_code/docs_ex9_annotated.py
+docs_code/index_example.py
 docs_code/tutorial_code.py
-perf/cluegen.py
-perf/dataklasses.py
-perf/hyperfine_testmaker.py
-perf/perf_profile.py
 src/ducktools/classbuilder/__init__.py
 src/ducktools/classbuilder/__init__.pyi
 src/ducktools/classbuilder/_version.py