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

ducktools/classbuilder/__init__.py

@@ -19,12 +19,19 @@
 # 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.3.0"
+import sys
+
+__version__ = "v0.5.0"
 
 # Change this name if you make heavy modifications
 INTERNALS_DICT = "__classbuilder_internals__"
 
 
+# If testing, make Field classes frozen to make sure attributes are not
+# overwritten. When running this is a performance penalty so it is not required.
+_UNDER_TESTING = "pytest" in sys.modules
+
+
 def get_fields(cls, *, local=False):
     """
     Utility function to gather the fields dictionary
@@ -58,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):
@@ -102,49 +109,55 @@ class MethodMaker:
         return method.__get__(instance, cls)
 
 
-def init_maker(cls, *, null=NOTHING, extra_code=None):
-    fields = get_fields(cls)
-    flags = get_flags(cls)
+def get_init_generator(null=NOTHING, extra_code=None):
+    def cls_init_maker(cls):
+        fields = get_fields(cls)
+        flags = get_flags(cls)
 
-    arglist = []
-    assignments = []
-    globs = {}
+        arglist = []
+        assignments = []
+        globs = {}
 
-    if flags.get("kw_only", False):
-        arglist.append("*")
+        if flags.get("kw_only", False):
+            arglist.append("*")
 
-    for k, v in fields.items():
-        if v.default is not null:
-            globs[f"_{k}_default"] = v.default
-            arg = f"{k}=_{k}_default"
-            assignment = f"self.{k} = {k}"
-        elif v.default_factory is not null:
-            globs[f"_{k}_factory"] = v.default_factory
-            arg = f"{k}=None"
-            assignment = f"self.{k} = _{k}_factory() if {k} is None else {k}"
-        else:
-            arg = f"{k}"
-            assignment = f"self.{k} = {k}"
+        for k, v in fields.items():
+            if v.default is not null:
+                globs[f"_{k}_default"] = v.default
+                arg = f"{k}=_{k}_default"
+                assignment = f"self.{k} = {k}"
+            elif v.default_factory is not null:
+                globs[f"_{k}_factory"] = v.default_factory
+                arg = f"{k}=None"
+                assignment = f"self.{k} = _{k}_factory() if {k} is None else {k}"
+            else:
+                arg = f"{k}"
+                assignment = f"self.{k} = {k}"
 
-        arglist.append(arg)
-        assignments.append(assignment)
+            arglist.append(arg)
+            assignments.append(assignment)
 
-    args = ", ".join(arglist)
-    assigns = "\n    ".join(assignments) if assignments else "pass\n"
-    code = (
-        f"def __init__(self, {args}):\n" 
-        f"    {assigns}\n"
-    )
-    # Handle additional function calls
-    # Used for validate_field on fieldclasses
-    if extra_code:
-        for line in extra_code:
-            code += f"    {line}\n"
+        args = ", ".join(arglist)
+        assigns = "\n    ".join(assignments) if assignments else "pass\n"
+        code = (
+            f"def __init__(self, {args}):\n" 
+            f"    {assigns}\n"
+        )
+        # Handle additional function calls
+        # Used for validate_field on fieldclasses
+        if extra_code:
+            for line in extra_code:
+                code += f"    {line}\n"
 
-    return code, globs
+        return code, globs
+
+    return cls_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}}"
@@ -158,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)
 
@@ -178,12 +191,55 @@ def eq_maker(cls):
     return code, globs
 
 
+def frozen_setattr_generator(cls):
+    globs = {}
+    field_names = set(get_fields(cls))
+    flags = get_flags(cls)
+
+    globs["__field_names"] = field_names
+
+    # 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["__setattr_func"] = object.__setattr__
+        setattr_method = "__setattr_func(self, name, value)"
+    else:
+        setattr_method = "self.__dict__[name] = value"
+
+    body = (
+        f"    if hasattr(self, name) or name not in __field_names:\n"
+        f'        raise TypeError(\n'
+        f'            f"{{type(self).__name__!r}} object does not support "'
+        f'            f"attribute assignment"\n'
+        f'        )\n'
+        f"    else:\n"
+        f"        {setattr_method}\n"
+    )
+    code = f"def __setattr__(self, name, value):\n{body}"
+
+    return code, globs
+
+
+def frozen_delattr_generator(cls):
+    body = (
+        '    raise TypeError(\n'
+        '        f"{type(self).__name__!r} object "\n'
+        '        f"does not support attribute deletion"\n'
+        '    )\n'
+    )
+    code = f"def __delattr__(self, name):\n{body}"
+    globs = {}
+    return code, globs
+
+
 # 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)
-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):
@@ -192,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
@@ -211,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
@@ -244,6 +307,8 @@ class Field:
     some metadata.
 
     Intended to be extendable by subclasses for additional features.
+
+    Note: When run under `pytest`, Field instances are Frozen.
     """
     __slots__ = {
         "default": "Standard default value to be used for attributes with"
@@ -303,14 +368,19 @@ _field_internal = {
     "doc": Field(default=None),
 }
 
+_field_methods = {repr_maker, eq_maker}
+if _UNDER_TESTING:
+    _field_methods.update({frozen_setattr_maker, frozen_delattr_maker})
+
 builder(
     Field,
-    gatherer=lambda cls_: _field_internal,
-    methods=frozenset({repr_desc, eq_desc}),
+    gatherer=lambda cls_: (_field_internal, {}),
+    methods=_field_methods,
     flags={"slotted": True, "kw_only": True},
 )
 
 
+# Slot gathering tools
 # Subclass of dict to be identifiable by isinstance checks
 # For anything more complicated this could be made into a Mapping
 class SlotFields(dict):
@@ -326,46 +396,170 @@ class SlotFields(dict):
     """
 
 
-def slot_gatherer(cls):
+def make_slot_gatherer(field_type=Field):
     """
-    Gather field information for class generation based on __slots__
-    
-    :param cls: Class to gather field information from
-    :return: dict of field_name: 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.
     """
-    cls_slots = cls.__dict__.get("__slots__", None)
+    def field_slot_gatherer(cls):
+        """
+        Gather field information for class generation based on __slots__
+
+        :param cls: Class to gather field information from
+        :return: dict of field_name: Field(...)
+        """
+        cls_slots = cls.__dict__.get("__slots__", None)
+
+        if not isinstance(cls_slots, SlotFields):
+            raise TypeError(
+                "__slots__ must be an instance of SlotFields "
+                "in order to generate a slotclass"
+            )
+
+        # 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():
+            if isinstance(v, field_type):
+                attrib = v
+                if attrib.type is not NOTHING:
+                    cls_annotations[k] = attrib.type
+            else:
+                # Plain values treated as defaults
+                attrib = field_type(default=v)
+
+            slot_replacement[k] = attrib.doc
+            cls_fields[k] = attrib
+
+        # 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,
+        }
+
+        return cls_fields, modifications
+
+    return field_slot_gatherer
 
-    if not isinstance(cls_slots, SlotFields):
-        raise TypeError(
-            "__slots__ must be an instance of SlotFields "
-            "in order to generate a slotclass"
-        )
 
-    cls_annotations = cls.__dict__.get("__annotations__", {})
-    cls_fields = {}
-    slot_replacement = {}
+slot_gatherer = make_slot_gatherer()
 
-    for k, v in cls_slots.items():
-        if isinstance(v, Field):
-            attrib = v
-            if v.type is not NOTHING:
-                cls_annotations[k] = attrib.type
+
+# Annotation gathering tools
+def is_classvar(hint):
+    _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:
-            # Plain values treated as defaults
-            attrib = Field(default=v)
+            _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
+        # String used as annotation
+        elif isinstance(hint, str) and "ClassVar" in hint:
+            return True
+    return False
+
+
+def make_annotation_gatherer(field_type=Field, leave_default_values=True):
+    """
+    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
+    :param leave_default_values: Set to True if the gatherer should leave
+                                 default values in place as class variables.
+    :return: An annotation gatherer with these settings.
+    """
+    def field_annotation_gatherer(cls):
+        cls_annotations = cls.__dict__.get("__annotations__", {})
+
+        cls_fields: dict[str, field_type] = {}
+
+        modifications = {}
+
+        for k, v in cls_annotations.items():
+            # Ignore ClassVar
+            if is_classvar(v):
+                continue
+
+            attrib = getattr(cls, k, NOTHING)
+
+            if attrib is not NOTHING:
+                if isinstance(attrib, field_type):
+                    attrib = field_type.from_field(attrib, type=v)
+                    if attrib.default is not NOTHING and leave_default_values:
+                        modifications[k] = attrib.default
+                    else:
+                        # NOTHING sentinel indicates a value should be removed
+                        modifications[k] = NOTHING
+                else:
+                    attrib = field_type(default=attrib, type=v)
+                    if not leave_default_values:
+                        modifications[k] = NOTHING
+
+            else:
+                attrib = field_type(type=v)
+
+            cls_fields[k] = attrib
 
-        slot_replacement[k] = attrib.doc
-        cls_fields[k] = attrib
+        return cls_fields, modifications
 
-    # Replace the SlotAttributes instance with a regular dict
-    # So that help() works
-    setattr(cls, "__slots__", slot_replacement)
+    return field_annotation_gatherer
 
-    # Update annotations with any types from the slots assignment
-    setattr(cls, "__annotations__", cls_annotations)
-    return cls_fields
 
+annotation_gatherer = make_annotation_gatherer()
 
+
+def check_argument_order(cls):
+    """
+    Raise a SyntaxError if the argument order will be invalid for a generated
+    `__init__` function.
+
+    :param cls: class being built
+    """
+    fields = get_fields(cls)
+    used_default = False
+    for k, v in fields.items():
+        if v.default is NOTHING and v.default_factory is NOTHING:
+            if used_default:
+                raise SyntaxError(
+                    f"non-default argument {k!r} follows default argument"
+                )
+        else:
+            used_default = True
+
+
+# Class Decorators
 def slotclass(cls=None, /, *, methods=default_methods, syntax_check=True):
     """
     Example of class builder in action using __slots__ to find fields.
@@ -382,40 +576,50 @@ def slotclass(cls=None, /, *, methods=default_methods, syntax_check=True):
     cls = builder(cls, gatherer=slot_gatherer, methods=methods, flags={"slotted": True})
 
     if syntax_check:
-        fields = get_fields(cls)
-        used_default = False
-        for k, v in fields.items():
-            if v.default is NOTHING and v.default_factory is NOTHING:
-                if used_default:
-                    raise SyntaxError(
-                        f"non-default argument {k!r} follows default argument"
-                    )
-            else:
-                used_default = True
+        check_argument_order(cls)
 
     return cls
 
 
-def _field_init_func(cls):
-    # Fields need a different Nothing for their __init__ generation
-    # And an extra call to validate_field
-    field_nothing = _NothingType()
-    extra_calls = ["self.validate_field()"]
-    return init_maker(cls, null=field_nothing, extra_code=extra_calls)
+def annotationclass(cls=None, /, *, methods=default_methods):
+    if not cls:
+        return lambda cls_: annotationclass(cls_, methods=methods)
+
+    cls = builder(cls, gatherer=annotation_gatherer, methods=methods, flags={"slotted": False})
+
+    check_argument_order(cls)
+
+    return cls
 
 
-def fieldclass(cls):
+_field_init_desc = MethodMaker(
+    funcname="__init__",
+    code_generator=get_init_generator(
+        null=_NothingType(),
+        extra_code=["self.validate_field()"],
+    )
+)
+
+
+def fieldclass(cls=None, /, *, frozen=False):
     """
     This is a special decorator for making Field subclasses using __slots__.
     This works by forcing the __init__ method to treat NOTHING as a regular
     value. This means *all* instance attributes always have defaults.
 
     :param cls: Field subclass
+    :param frozen: Make the field class a frozen class.
+                   Field classes are always frozen when running under `pytest`
     :return: Modified subclass
     """
+    if not cls:
+        return lambda cls_: fieldclass(cls_, frozen=frozen)
+
+    field_methods = {_field_init_desc, repr_maker, eq_maker}
 
-    field_init_desc = MethodMaker("__init__", _field_init_func)
-    field_methods = frozenset({field_init_desc, repr_desc, eq_desc})
+    # Always freeze when running tests
+    if frozen or _UNDER_TESTING:
+        field_methods.update({frozen_setattr_maker, frozen_delattr_maker})
 
     cls = builder(
         cls,

ducktools/classbuilder/__init__.pyi

@@ -26,18 +26,24 @@ class MethodMaker:
     def __repr__(self) -> str: ...
     def __get__(self, instance, cls) -> Callable: ...
 
-def init_maker(
-    cls: type,
-    *,
+def get_init_generator(
     null: _NothingType = NOTHING,
     extra_code: None | list[str] = None
-) -> 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]]: ...
+) -> Callable[[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_generator(cls: type) -> tuple[str, dict[str, typing.Any]]: ...
 
-init_desc: MethodMaker
-repr_desc: MethodMaker
-eq_desc: MethodMaker
+def frozen_delattr_generator(cls: type) -> tuple[str, dict[str, typing.Any]]: ...
+
+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")
@@ -47,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]: ...
@@ -57,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]]: ...
@@ -89,9 +95,24 @@ class Field:
 class SlotFields(dict):
     ...
 
-def slot_gatherer(cls: 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) -> tuple[dict[str, Field], dict[str, typing.Any]]:
     ...
 
+def is_classvar(hint: object) -> bool: ...
+
+def make_annotation_gatherer(
+    field_type: type[Field] = Field,
+    leave_default_values: bool = True,
+) -> Callable[[type], tuple[dict[str, Field], dict[str, typing.Any]]]: ...
+
+def annotation_gatherer(cls: type) -> tuple[dict[str, Field], dict[str, typing.Any]]: ...
+
+def check_argument_order(cls: type) -> None: ...
+
 @typing.overload
 def slotclass(
     cls: type[_T],
@@ -110,4 +131,24 @@ def slotclass(
     syntax_check: bool = True
 ) -> Callable[[type[_T]], type[_T]]: ...
 
-def fieldclass(cls: type[_T]) -> type[_T]: ...
+@typing.overload
+def annotationclass(
+    cls: type[_T],
+    /,
+    *,
+    methods: frozenset[MethodMaker] | set[MethodMaker] = default_methods,
+) -> type[_T]: ...
+
+@typing.overload
+def annotationclass(
+        cls: None = None,
+        /,
+        *,
+        methods: frozenset[MethodMaker] | set[MethodMaker] = default_methods,
+) -> Callable[[type[_T]], type[_T]]: ...
+
+@typing.overload
+def fieldclass(cls: type[_T], /, *, frozen: bool = False) -> type[_T]: ...
+
+@typing.overload
+def fieldclass(cls: None = None, /, *, frozen: bool = False) -> Callable[[type[_T]], type[_T]]: ...

ducktools/classbuilder/prefab.py

@@ -31,7 +31,8 @@ import sys
 from . import (
     INTERNALS_DICT, NOTHING,
     Field, MethodMaker, SlotFields,
-    builder, fieldclass, get_flags, get_fields, slot_gatherer
+    builder, fieldclass, get_flags, get_fields, make_slot_gatherer,
+    frozen_setattr_maker, frozen_delattr_maker, is_classvar,
 )
 
 PREFAB_FIELDS = "PREFAB_FIELDS"
@@ -55,20 +56,6 @@ class PrefabError(Exception):
     pass
 
 
-def _is_classvar(hint):
-    _typing = sys.modules.get("typing")
-    if _typing:
-        if (
-            hint is _typing.ClassVar
-            or getattr(hint, "__origin__", None) is _typing.ClassVar
-        ):
-            return True
-        # String used as annotation
-        elif isinstance(hint, str) and "ClassVar" in hint:
-            return True
-    return False
-
-
 def get_attributes(cls):
     """
     Copy of get_fields, typed to return Attribute instead of Field.
@@ -340,57 +327,6 @@ def get_iter_maker():
     return MethodMaker("__iter__", __iter__)
 
 
-def get_frozen_setattr_maker():
-    def __setattr__(cls: "type") -> "tuple[str, dict]":
-        globs = {}
-        attributes = get_attributes(cls)
-        flags = get_flags(cls)
-
-        # Make the fields set literal
-        fields_delimited = ", ".join(f"{field!r}" for field in attributes)
-        field_set = f"{{ {fields_delimited} }}"
-
-        # 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:
-            setattr_method = "self.__dict__[name] = value"
-
-        body = (
-            f"    if hasattr(self, name) or name not in {field_set}:\n"
-            f'        raise TypeError(\n'
-            f'            f"{{type(self).__name__!r}} object does not support "'
-            f'            f"attribute assignment"\n'
-            f'        )\n'
-            f"    else:\n"
-            f"        {setattr_method}\n"
-        )
-        code = f"def __setattr__(self, name, value):\n{body}"
-
-        return code, globs
-
-    # Pass the exception to exec
-    return MethodMaker("__setattr__", __setattr__)
-
-
-def get_frozen_delattr_maker():
-    # noinspection PyUnusedLocal
-    def __delattr__(cls: "type") -> "tuple[str, dict]":
-        body = (
-            '    raise TypeError(\n'
-            '        f"{type(self).__name__!r} object "\n'
-            '        f"does not support attribute deletion"\n'
-            '    )\n'
-        )
-        code = f"def __delattr__(self, name):\n{body}"
-        globs = {}
-        return code, globs
-
-    return MethodMaker("__delattr__", __delattr__)
-
-
 def get_asdict_maker():
     def as_dict_gen(cls: "type") -> "tuple[str, dict]":
         fields = get_attributes(cls)
@@ -408,15 +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()
-frozen_setattr_desc = get_frozen_setattr_maker()
-frozen_delattr_desc = get_frozen_delattr_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
@@ -491,12 +425,7 @@ 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()
-    }
+slot_prefab_gatherer = make_slot_gatherer(Attribute)
 
 
 # Gatherer for classes built on attributes or annotations
@@ -512,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.
@@ -519,7 +450,7 @@ def attribute_gatherer(cls):
         new_attributes = {}
         for name, value in cls_annotations.items():
             # Ignore ClassVar hints
-            if _is_classvar(value):
+            if is_classvar(value):
                 continue
 
             # Look for the KW_ONLY annotation
@@ -533,39 +464,45 @@ def attribute_gatherer(cls):
                 # Copy attributes that are already defined to the new dict
                 # generate Attribute() values for those that are not defined.
 
+                # Extra parameters to pass to each Attribute
+                extras = {
+                    "type": cls_annotations[name]
+                }
+                if kw_flag:
+                    extras["kw_only"] = True
+
                 # If a field name is also declared in slots it can't have a real
                 # default value and the attr will be the slot descriptor.
                 if hasattr(cls, name) and name not in cls_slots:
                     if name in cls_attribute_names:
-                        attrib = cls_attributes[name]
+                        attrib = Attribute.from_field(
+                            cls_attributes[name],
+                            **extras,
+                        )
                     else:
                         attribute_default = getattr(cls, name)
-                        attrib = attribute(default=attribute_default)
+                        attrib = attribute(default=attribute_default, **extras)
 
                     # Clear the attribute from the class after it has been used
                     # in the definition.
-                    delattr(cls, name)
+                    cls_modifications[name] = NOTHING
                 else:
-                    attrib = attribute()
+                    attrib = attribute(**extras)
 
-                if kw_flag:
-                    attrib.kw_only = True
-
-                attrib.type = cls_annotations[name]
                 new_attributes[name] = attrib
 
         cls_attributes = new_attributes
     else:
-        for name, attrib in cls_attributes.items():
-            delattr(cls, name)
+        for name in cls_attributes.keys():
+            attrib = cls_attributes[name]
+            cls_modifications[name] = NOTHING
 
             # Some items can still be annotated.
-            try:
-                attrib.type = cls_annotations[name]
-            except KeyError:
-                pass
+            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
@@ -619,24 +556,24 @@ def _make_prefab(
     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,
@@ -912,17 +849,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
@@ -26,8 +26,6 @@ KW_ONLY: _KW_ONLY_TYPE
 
 class PrefabError(Exception): ...
 
-def _is_classvar(hint: type | str) -> bool: ...
-
 def get_attributes(cls: type) -> dict[str, Attribute]: ...
 
 def get_init_maker(*, init_name: str="__init__") -> MethodMaker: ...
@@ -38,22 +36,16 @@ def get_eq_maker() -> MethodMaker: ...
 
 def get_iter_maker() -> MethodMaker: ...
 
-def get_frozen_setattr_maker() -> MethodMaker: ...
-
-def get_frozen_delattr_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
-frozen_setattr_desc: MethodMaker
-frozen_delattr_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
@@ -101,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,

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ducktools-classbuilder
-Version: 0.3.0
+Version: 0.5.0
 Summary: Toolkit for creating class boilerplate generators
 Author: David C Ellis
 License: MIT License
@@ -45,6 +45,7 @@ Provides-Extra: testing
 Requires-Dist: pytest ; extra == 'testing'
 Requires-Dist: pytest-cov ; extra == 'testing'
 Requires-Dist: mypy ; extra == 'testing'
+Requires-Dist: typing-extensions ; (python_version < "3.10") and extra == 'testing'
 
 # Ducktools: Class Builder #
 
@@ -68,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 
@@ -90,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 ##
@@ -121,7 +124,7 @@ a similar manner to the `@dataclass` decorator from `dataclasses`.
 > be used directly. (The included version has some extra features).
 
 ```python
-from ducktools.classbuilder import Field, SlotFields
+from ducktools.classbuilder import Field, SlotFields, slotclass
 
 @slotclass
 class SlottedDC:
@@ -206,6 +209,25 @@ print(f"{DataCoords is class_register[DataCoords.__name__] = }")
 print(f"{SlotCoords is class_register[SlotCoords.__name__] = }")
 ```
 
+## Using annotations anyway ##
+
+For those that really want to use type annotations a basic `annotation_gatherer`
+function and `@annotationclass` decorator are also included. Slots are not generated
+in this case.
+
+```python
+from ducktools.classbuilder import annotationclass
+
+@annotationclass
+class AnnotatedDC:
+    the_answer: int = 42
+    the_question: str = "What do you get if you multiply six by nine?"
+
+    
+ex = AnnotatedDC()
+print(ex)
+```
+
 ## What features does this have? ##
 
 Included as an example implementation, the `slotclass` generator supports 
@@ -218,6 +240,9 @@ 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 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.0.dist-info/RECORD

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

ducktools_classbuilder-0.3.0.dist-info/RECORD

@@ -1,10 +0,0 @@
-ducktools/classbuilder/__init__.py,sha256=Vw5RjzzIkXGYXKOmFWTxPsIAM4ceg74Q1Oku4fwF0ek,13505
-ducktools/classbuilder/__init__.pyi,sha256=hgcEylMAHgfonOt2fH9OCE3gU60mYkiOUe7e8mTwNVs,2857
-ducktools/classbuilder/prefab.py,sha256=gJJCtTAbQLgIoo79jRWVp09r3u8kJjcqXp4G4FTu9j8,29887
-ducktools/classbuilder/prefab.pyi,sha256=vcaEpBxyVsOTwkGBkVgmbpn8DPqQqFnAU4xTKPnpOd8,3977
-ducktools/classbuilder/py.typed,sha256=la67KBlbjXN-_-DfGNcdOcjYumVpKG_Tkw-8n5dnGB4,8
-ducktools_classbuilder-0.3.0.dist-info/LICENSE.md,sha256=6Thz9Dbw8R4fWInl6sGl8Rj3UnKnRbDwrc6jZerpugQ,1070
-ducktools_classbuilder-0.3.0.dist-info/METADATA,sha256=sAWw76LgN3HruCS-SXURrrAj2A6MmhsyDJwMSvnWW2w,9280
-ducktools_classbuilder-0.3.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-ducktools_classbuilder-0.3.0.dist-info/top_level.txt,sha256=uSDLtio3ZFqdwcsMJ2O5yhjB4Q3ytbBWbA8rJREganc,10
-ducktools_classbuilder-0.3.0.dist-info/RECORD,,