ducktools-classbuilder 0.10.2__tar.gz → 0.11.1__tar.gz

ducktools_classbuilder-0.11.1/MANIFEST.in

@@ -0,0 +1,5 @@
+exclude .readthedocs.yaml
+
+prune .github
+prune docs_code
+prune perf

{ducktools_classbuilder-0.10.2 → ducktools_classbuilder-0.11.1}/PKG-INFO

@@ -1,8 +1,9 @@
 Metadata-Version: 2.4
 Name: ducktools-classbuilder
-Version: 0.10.2
+Version: 0.11.1
 Summary: Toolkit for creating class boilerplate generators
 Author: David C Ellis
+License-Expression: MIT
 Project-URL: Homepage, https://github.com/davidcellis/ducktools-classbuilder
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python :: 3.10
@@ -11,7 +12,6 @@ Classifier: Programming Language :: Python :: 3.12
 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.10
 Description-Content-Type: text/markdown
 License-File: LICENSE

ducktools_classbuilder-0.11.1/docs/api.md

@@ -0,0 +1,82 @@
+# Builder API Autodocs #
+
+## Slotclass example functions and classes ##
+
+```{eval-rst}
+.. autoclass:: ducktools.classbuilder::Field
+```
+
+```{eval-rst}
+.. autoclass:: ducktools.classbuilder::SlotFields
+```
+
+```{eval-rst}
+.. autofunction:: ducktools.classbuilder::slotclass
+```
+
+
+## Builder functions and classes ##
+
+```{eval-rst}
+.. autofunction:: ducktools.classbuilder::builder
+```
+
+```{eval-rst}
+.. autofunction:: ducktools.classbuilder::get_fields
+```
+
+```{eval-rst}
+.. autofunction:: ducktools.classbuilder::get_flags
+```
+
+```{eval-rst}
+.. autofunction:: ducktools.classbuilder::get_methods
+```
+
+```{eval-rst}
+.. autoclass:: ducktools.classbuilder::MethodMaker
+```
+
+```{eval-rst}
+.. autofunction:: ducktools.classbuilder::make_unified_gatherer
+```
+
+## Prefab Class and Attributes ##
+
+```{eval-rst}
+.. autofunction:: ducktools.classbuilder.prefab::prefab
+```
+
+```{eval-rst}
+.. autoclass:: ducktools.classbuilder.prefab::Prefab
+   :members: __init_subclass__
+```
+
+```{eval-rst}
+.. autofunction:: ducktools.classbuilder.prefab::attribute
+```
+
+```{eval-rst}
+.. autofunction:: ducktools.classbuilder.prefab::get_attributes
+```
+
+```{eval-rst}
+.. autofunction:: ducktools.classbuilder.prefab::build_prefab
+```
+
+```{eval-rst}
+.. autofunction:: ducktools.classbuilder.prefab::is_prefab
+```
+
+```{eval-rst}
+.. autofunction:: ducktools.classbuilder.prefab::is_prefab_instance
+```
+
+```{eval-rst}
+.. autofunction:: ducktools.classbuilder.prefab::as_dict
+```
+
+```{eval-rst}
+.. autofunction:: ducktools.classbuilder.prefab::replace
+```
+

ducktools_classbuilder-0.10.2/docs_code/docs_ex9_annotated.py → ducktools_classbuilder-0.11.1/docs/code_examples/docs_ex09_annotated.py

@@ -1,3 +1,8 @@
+# Don't use __future__ annotations with get_ns_annotations in this case
+# as it doesn't evaluate string annotations.
+
+# NOTE: In Python 3.14 this will currently only work if there are *no* forward references.
+
 import types
 from typing import Annotated, Any, ClassVar, get_origin
 
@@ -6,10 +11,8 @@ from ducktools.classbuilder import (
     default_methods,
     get_fields,
     get_methods,
-    pre_gathered_gatherer,
     Field,
     SlotMakerMeta,
-    GATHERED_DATA,
     NOTHING,
 )
 
@@ -112,14 +115,13 @@ def annotatedclass(cls=None, *, kw_only=False):
 
 # As a base class with slots
 class AnnotatedClass(metaclass=SlotMakerMeta, gatherer=annotated_gatherer):
-    
+
     def __init_subclass__(cls, kw_only=False, **kwargs):
-        pre_gathered = GATHERED_DATA in cls.__dict__
         slots = "__slots__" in cls.__dict__
 
         # if slots is True then fields will already be present in __slots__
         # Use the slot_gatherer for this case
-        gatherer = pre_gathered_gatherer if pre_gathered else annotated_gatherer
+        gatherer = annotated_gatherer
 
         builder(
             cls,
@@ -177,7 +179,7 @@ if __name__ == "__main__":
     methods = get_methods(X)
 
     # Call the code generators to display the source code
-    for method in methods.values():
+    for _, method in sorted(methods.items()):
         # Both classes generate identical source code
         genX = method.code_generator(X)
         genY = method.code_generator(Y)

ducktools_classbuilder-0.11.1/docs/code_examples/outputs/docs_ex01_basic.output

@@ -0,0 +1,36 @@
+SlottedDC(the_answer=42, the_question='What do you get if you multiply six by nine?')
+Help on class SlottedDC in module __main__:
+
+class SlottedDC(builtins.object)
+ |  SlottedDC(
+ |      the_answer=42,
+ |      the_question='What do you get if you multiply six by nine?'
+ |  )
+ |
+ |  Methods defined here:
+ |
+ |  __eq__(self, other) from SlottedDC
+ |
+ |  __init__(
+ |      self,
+ |      the_answer=42,
+ |      the_question='What do you get if you multiply six by nine?'
+ |  ) from SlottedDC
+ |
+ |  __repr__(self) from SlottedDC
+ |
+ |  __signature__
+ |
+ |  ----------------------------------------------------------------------
+ |  Data descriptors defined here:
+ |
+ |  the_answer
+ |
+ |  the_question
+ |      Life, the Universe, and Everything
+ |
+ |  ----------------------------------------------------------------------
+ |  Data and other attributes defined here:
+ |
+ |  __classbuilder_internals__ = {'build_complete': True, 'fields': {'the_...
+

ducktools_classbuilder-0.11.1/docs/code_examples/outputs/docs_ex02_register.output

@@ -0,0 +1,4 @@
+DataCoords(x=0.0, y=0.0)
+SlotCoords(x=0.0, y=0.0)
+DataCoords is class_register[DataCoords.__name__] = False
+SlotCoords is class_register[SlotCoords.__name__] = True

ducktools_classbuilder-0.11.1/docs/code_examples/outputs/docs_ex03_iterable.output

@@ -0,0 +1,2 @@
+[1, 2, 3, 4, 5]
+[]

ducktools_classbuilder-0.11.1/docs/code_examples/outputs/docs_ex05_frozen.output

@@ -0,0 +1,4 @@
+FrozenEx(x=6, y=9, product=42)
+'FrozenEx' object does not support attribute assignment
+'FrozenEx' object does not support attribute assignment
+'FrozenEx' object does not support attribute deletion

ducktools_classbuilder-0.11.1/docs/code_examples/outputs/docs_ex07_posonly.output

@@ -0,0 +1,4 @@
+WorkingEx(42, x=6, y=9)
+WorkingEx(42, x=6, y=9)
+WorkingEx.__init__() got some positional-only arguments passed as keyword arguments: 'a'
+Positional only parameter 'x' follows keyword parameters on 'FailEx'

ducktools_classbuilder-0.11.1/docs/code_examples/outputs/docs_ex08_converters.output

@@ -0,0 +1 @@
+ConverterEx(unconverted='42', converted=42)

ducktools_classbuilder-0.11.1/docs/code_examples/outputs/docs_ex09_annotated.output

@@ -0,0 +1,33 @@
+X(x='Value of x', a='Not In __init__ signature', c=[], e='Value of e') 
+
+{'x': Field(default=<NOTHING OBJECT>, default_factory=<NOTHING OBJECT>, type=<class 'str'>, doc=None, init=True, repr=True, compare=True, kw_only=False),
+ 'a': Field(default='Not In __init__ signature', default_factory=<NOTHING OBJECT>, type=<class 'int'>, doc=None, init=False, repr=True, compare=True, kw_only=False),
+ 'b': Field(default='Not In Repr', default_factory=<NOTHING OBJECT>, type=<class 'str'>, doc=None, init=True, repr=False, compare=True, kw_only=False),
+ 'c': Field(default=<NOTHING OBJECT>, default_factory=<class 'list'>, type=list[str], doc=None, init=True, repr=True, compare=False, kw_only=False),
+ 'd': Field(default='Not Anywhere', default_factory=<NOTHING OBJECT>, type=<class 'str'>, doc=None, init=False, repr=False, compare=False, kw_only=False),
+ 'e': Field(default=<NOTHING OBJECT>, default_factory=<NOTHING OBJECT>, type=<class 'str'>, doc=None, init=True, repr=True, compare=False, kw_only=True)}
+
+
+Y(x='Value of x', a='Not In __init__ signature', c=[], e='Value of e') 
+
+Slots: {'x': None, 'a': None, 'b': None, 'c': None, 'd': None, 'e': None}
+
+Source:
+def __eq__(self, other):
+    return (
+        self.x == other.x
+        and self.a == other.a
+        and self.b == other.b
+    ) if self.__class__ is other.__class__ else NotImplemented
+
+def __init__(self, x, b=_b_default, c=None, *, e):
+    self.x = x
+    self.a = _a_default
+    self.b = b
+    self.c = _c_factory() if c is None else c
+    self.d = _d_default
+    self.e = e
+
+def __repr__(self):
+    return f'{type(self).__qualname__}(x={self.x!r}, a={self.a!r}, c={self.c!r}, e={self.e!r})'
+

ducktools_classbuilder-0.11.1/docs/code_examples/outputs/docs_ex10_frozen_attributes.output

@@ -0,0 +1 @@
+AttributeError("Attribute 'b' does not support assignment")

ducktools_classbuilder-0.11.1/docs/code_examples/outputs/index_example.output

@@ -0,0 +1 @@
+AnnotatedDC(the_answer=42, the_question='What do you get if you multiply six by nine?')

ducktools_classbuilder-0.11.1/docs/code_examples/outputs/tutorial_code.output

@@ -0,0 +1,13 @@
+({'field_1': CustomField(default='First Field', default_factory=<NOTHING OBJECT>, type=<NOTHING OBJECT>, doc=None, init=True, repr=True, compare=True, kw_only=False, report=True),
+  'field_2': CustomField(default='Second Field', default_factory=<NOTHING OBJECT>, type=<NOTHING OBJECT>, doc=None, init=True, repr=True, compare=True, kw_only=False, report=True),
+  'field_3': CustomField(default='Third Field', default_factory=<NOTHING OBJECT>, type=<NOTHING OBJECT>, doc=None, init=True, repr=True, compare=True, kw_only=False, report=False)},
+ {'__fields__': None})
+@property
+def report(self):
+    return f"Class: CodegenDemo\nfield_1: {self.field_1!r}\nfield_2: {self.field_2!r}\nfield_3: {self.field_3!r}"
+Class: Example
+x: 42
+y: <HIDDEN>
+Class: ExampleSlots
+x: 42
+y: <HIDDEN>

{ducktools_classbuilder-0.10.2/docs_code → ducktools_classbuilder-0.11.1/docs/code_examples}/tutorial_code.py

@@ -117,11 +117,9 @@ slot_gatherer = dtbuild.make_slot_gatherer(CustomField)
 
 class ReportClass(metaclass=dtbuild.SlotMakerMeta, gatherer=fields_attribute_gatherer):
     __slots__ = {}
-    
+
     def __init_subclass__(cls):
-        # Check if the metaclass has pre-gathered data
-        pre_gathered = dtbuild.GATHERED_DATA in vars(cls)
-        gatherer = dtbuild.pre_gathered_gatherer if pre_gathered else fields_attribute_gatherer
+        gatherer = fields_attribute_gatherer
         methods = {
             dtbuild.eq_maker,
             dtbuild.repr_maker,

ducktools_classbuilder-0.11.1/docs/extension_examples.md

@@ -0,0 +1,94 @@
+# Examples of extending builders #
+
+Here are some examples of adding specific features to classes using the tools provided
+by the `ducktools.classbuilder` module.
+
+## How can I add `<method>` to the class ##
+
+To do this you need to write a code generator that returns source code
+along with a 'globals' dictionary of any names the code needs to refer
+to, or an empty dictionary if none are needed. Many methods don't require
+any globals values, but it is essential for some.
+
+### Frozen Classes ###
+
+In order to make frozen classes you need to replace `__setattr__` and `__delattr__`
+
+The building blocks for this are actually already included as they're used to prevent
+`Field` subclass instances from being mutated when under testing.
+
+These methods can be reused to make `slotclasses` 'frozen'.
+
+```{literalinclude} code_examples/docs_ex05_frozen.py
+```
+
+### Iterable Classes ###
+
+Say you want to make the class iterable, so you want to add `__iter__`.
+
+```{literalinclude} code_examples/docs_ex03_iterable.py
+```
+
+You could also choose to yield tuples of `name, value` pairs in your implementation.
+
+## Extending Field ##
+
+The `Field` class can also be extended as if it is a slotclass, with annotations or
+with `Field` declarations.
+
+One notable caveat - if you want to use a `default_factory` in extending `Field` you
+need to declare `default=FIELD_NOTHING` also in order for default to be ignored. This
+is a special case for `Field` and is not needed in general.
+
+```python
+from ducktools.classbuilder import Field, FIELD_NOTHING
+
+class MetadataField(Field):
+    metadata: dict = Field(default=FIELD_NOTHING, default_factory=dict)
+```
+
+In regular classes the `__init__` function generator considers `NOTHING` to be an
+ignored value, but for `Field` subclasses it is a valid value so `FIELD_NOTHING` is
+the ignored term. This is all because `None` *is* a valid value and can't be used
+as a sentinel for Fields (otherwise `Field(default=None)` couldn't work).
+
+### Positional Only Arguments? ###
+
+This is possible, but a little longer as we also need to modify multiple methods
+along with adding a check to the builder to catch likely errors before the `__init__`
+method is generated.
+
+For simplicity this demonstration version will ignore the existence of the kw_only
+parameter for fields.
+
+```{literalinclude} code_examples/docs_ex07_posonly.py
+```
+
+### Frozen Attributes ###
+
+Here's an implementation that allows freezing of individual attributes.
+
+```{literalinclude} code_examples/docs_ex10_frozen_attributes.py
+```
+
+### Converters ###
+
+Here's an implementation of basic converters that always convert when
+their attribute is set.
+
+```{literalinclude} code_examples/docs_ex08_converters.py
+```
+
+## Gatherers ##
+### What about using annotations instead of `Field(init=False, ...)` ###
+
+This seems to be a feature people keep requesting for `dataclasses`.
+
+To implement this you need to create a new annotated_gatherer function.
+
+> Note: Field classes will be frozen when running under pytest.
+>       They should not be mutated by gatherers.
+>       If you need to change the value of a field use Field.from_field(...) to make a new instance.
+
+```{literalinclude} code_examples/docs_ex09_annotated.py
+```

{ducktools_classbuilder-0.10.2 → ducktools_classbuilder-0.11.1}/docs/index.md

@@ -7,12 +7,12 @@ caption: "Contents:"
 hidden: true
 ---
 tutorial
+prefab/index
 extension_examples
 generated_code
 api
 perf/performance_tests
 approach_vs_tool
-prefab/index
 ```
 
 `ducktools-classbuilder` is *the* Python package that will bring you the **joy**
@@ -22,14 +22,14 @@ Maybe.
 
 This specific idea came about after seeing people making multiple feature requests
 to `attrs` or `dataclasses` to add features or to merge feature PRs. This project
-is supposed to both provide users with some basic tools to allow them to make 
+is supposed to both provide users with some basic tools to allow them to make
 custom class generators that work with the features they need.
 
 ## A little history ##
 
 Previously I had a project - `PrefabClasses` - which came about while getting
 frustrated at the need to write converters or wrappers for multiple methods when
-using `attrs`, where all I really wanted to do was coerce empty values to None 
+using `attrs`, where all I really wanted to do was coerce empty values to None
 (or the other way around).
 
 Further development came when I started investigating CLI tools and noticed the
@@ -48,21 +48,7 @@ modules, including stdlib ones that would have a significant impact on start tim
 The building toolkit includes a basic implementation that uses
 `__slots__` to define the fields by assigning a `SlotFields` instance.
 
-```python
-from ducktools.classbuilder import slotclass, Field, SlotFields
-
-@slotclass
-class SlottedDC:
-    __slots__ = SlotFields(
-        the_answer=42,
-        the_question=Field(
-            default="What do you get if you multiply six by nine?",
-            doc="Life, the Universe, and Everything",
-        ),
-    )
-    
-ex = SlottedDC()
-print(ex)
+```{literalinclude} code_examples/docs_ex01_basic.py
 ```
 
 ## Using Annotations ##
@@ -75,41 +61,7 @@ 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 (
-    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)
+```{literalinclude} code_examples/index_example.py
 ```
 
 ## Indices and tables ##

{ducktools_classbuilder-0.10.2 → ducktools_classbuilder-0.11.1}/docs/prefab/index.md

@@ -1,17 +1,13 @@
 # Prefab - A prebuilt classbuilder implementation  #
 
-Writes the class boilerplate code so you don't have to.
-
-Unlike `slotclass` in classbuilder this is a more featureful implementation.
+This is a more full featured dataclass replacement with some different design decisions
+and features.
 
 Including:
 * Declaration by type hints, slots or `attribute(...)` assignment on the class
-* `attribute` arguments to include/exclude fields from specific methods or to make them keyword only
-* `prefab` arguments to modify class generation options
 * `__prefab_pre_init__` and `__prefab_post_init__` detection to allow for validation/conversion
-* Frozen classes
-* Optional `as_dict` method generation
-* Optional recursive `__repr__` handling
+* Optional `as_dict` method generation to convert to a dictionary
+* Optional recursive `__repr__` handling (off by default)
 
 ## Usage ##
 
@@ -27,7 +23,7 @@ class Settings:
     template_name = attribute(default='index')
 ```
 
-Or with type hinting:
+Or with type hints:
 
 ```python
 from ducktools.classbuilder.prefab import prefab
@@ -49,24 +45,16 @@ Settings(hostname='localhost', template_folder='base/path', template_name='index
 
 ## Slots ##
 
-Classes can also be created using `__slots__` in the same way as `@slotclass` from the builder,
-but with all of the additional features added by `prefab`
-
-Similarly to the type hinted form, plain values given to a SlotFields instance are treated as defaults
-while `attribute` calls are handled normally. `doc` values will be seen when calling `help(...)` on the class
-while the `__annotations__` dictionary will be updated with `type` values given. Annotations can also still
-be given normally (which will probably be necessary for static typing tools).
+Pre-slotted classes can be created by using the `Prefab` base class
 
 ```python
-from ducktools.classbuilder.prefab import prefab, attribute, SlotFields
+from ducktools.classbuilder.prefab import Prefab
 
-@prefab
-class Settings:
-    __slots__ = SlotFields(
-        hostname="localhost",
-        template_folder="base/path",
-        template_name=attribute(default="index", type=str, doc="Name of the template"),
-    )
+
+class Settings(Prefab):
+    hostname: str = "localhost"
+    template_folder: str = 'base/path'
+    template_name: str = 'index'
 ```
 
 ## Why not just use attrs or dataclasses? ##
@@ -76,27 +64,10 @@ They are thoroughly tested, well supported packages. This is a new
 project and has not had the rigorous real world testing of either
 of those.
 
-This module has been created for situations where startup time is important, 
+This module has been created for situations where startup time is important,
 such as for CLI tools and for handling conversion of inputs in a way that
 was more useful to me than attrs converters (`__prefab_post_init__`).
 
-## How does it work ##
-
-The `@prefab` decorator analyses the class it is decorating and prepares an internals dict, along
-with performing some other early checks.
-Once this is done it sets any direct values (`PREFAB_FIELDS` and `__match_args__` if required) 
-and places non-data descriptors for all of the magic methods to be generated.
-
-The non-data descriptors for each of the magic methods perform code generation when first called
-in order to generate the actual methods. Once the method has been generated, the descriptor is 
-replaced on the class with the resulting method so there is no overhead regenerating the method
-on each access. 
-
-By only generating methods the first time they are used the start time can be
-improved and methods that are never used don't have to be created at all (for example the 
-`__repr__` method is useful when debugging but may not be used in normal runtime). In contrast
-`dataclasses` generates all of its methods when the class is created.
-
 ## Pre and Post Init Methods ##
 
 Alongside the standard method generation `@prefab` decorated classes
@@ -105,7 +76,7 @@ methods are defined.
 
 For both methods if they have additional arguments with names that match
 defined attributes, the matching arguments to `__init__` will be passed
-through to the method. 
+through to the method.
 
 **If an argument is passed to `__prefab_post_init__`it will not be initialized
 in `__init__`**. It is expected that initialization will occur in the method
@@ -129,7 +100,7 @@ from ducktools.classbuilder.prefab import prefab
 @prefab(repr=False, eq=False)
 class ExampleValidate:
     x: int
-    
+
     @staticmethod
     def __prefab_pre_init__(x):
         if x <= 0:
@@ -142,11 +113,11 @@ Equivalent code:
 class ExampleValidate:
     PREFAB_FIELDS = ['x']
     __match_args__ = ('x',)
-    
+
     def __init__(self, x: int):
         self.__prefab_pre_init__(x=x)
         self.x = x
-    
+
     @staticmethod
     def __prefab_pre_init__(x):
         if x <= 0:
@@ -176,12 +147,12 @@ from pathlib import Path
 class ExampleConvert:
     PREFAB_FIELDS = ['x']
     __match_args__ = ('x',)
-    
+
     x: Path
-    
+
     def __init__(self, x: Path | str = 'path/to/source'):
         self.__prefab_post_init__(x=x)
-    
+
     def __prefab_post_init__(self, x: Path | str):
         self.x = Path(x)
 ```
@@ -202,7 +173,7 @@ or will be added to this list.
 1. prefabs do not generate the comparison methods other than `__eq__`.
     * This isn't generally a feature I want or use, however with the tools it is easy
       to add if this is a needed feature.
-1. the `as_dict` method in `prefab_classes` does *not* behave the same as 
+1. the `as_dict` method in `prefab_classes` does *not* behave the same as
    dataclasses' `asdict`.
     * `as_dict` does *not* deepcopy the included fields, modification of mutable
       fields in the dictionary will modify them in the original object.
@@ -233,7 +204,7 @@ or will be added to this list.
    but renamed to `__prefab_init__`.
 1. Slots are supported but not from annotations using the decorator `@prefab`
     * The support for slots in `attrs` and `dataclasses` involves recreating the
-      class as it is not possible to effectively define `__slots__` after class 
+      class as it is not possible to effectively define `__slots__` after class
       creation. This can cause bugs where decorators or caches hold references
       to the original class.
     * `@prefab` can be used if the slots are provided with a `__slots__ = SlotFields(...)`
@@ -251,28 +222,3 @@ or will be added to this list.
       look like it would `eval`.
 1. default_factory functions will be called if `None` is passed as an argument
     * This makes it easier to wrap the function.
-
-
-## API Autodocs ##
-
-### Core Functions ###
-
-```{eval-rst}
-.. autofunction:: ducktools.classbuilder.prefab::prefab
-```
-
-```{eval-rst}
-.. autofunction:: ducktools.classbuilder.prefab::attribute
-```
-
-```{eval-rst}
-.. autofunction:: ducktools.classbuilder.prefab::build_prefab
-```
-
-### Helper functions ###
-
-```{eval-rst}
-.. autofunction:: ducktools.classbuilder.prefab::is_prefab
-.. autofunction:: ducktools.classbuilder.prefab::is_prefab_instance
-.. autofunction:: ducktools.classbuilder.prefab::as_dict
-```