ducktools-classbuilder 0.2.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

ducktools/classbuilder/__init__.py

@@ -19,32 +19,17 @@
 # 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.2.1"
+import sys
+
+__version__ = "v0.4.0"
 
 # Change this name if you make heavy modifications
 INTERNALS_DICT = "__classbuilder_internals__"
 
 
-def get_internals(cls):
-    """
-    Utility function to get the internals dictionary
-    or return None.
-
-    As generated classes will always have 'fields'
-    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):
-           ...
-
-    :param cls: generated class
-    :return: internals dictionary of the class or None
-    """
-    return getattr(cls, INTERNALS_DICT, None)
+# 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):
@@ -71,7 +56,9 @@ def get_flags(cls):
     return getattr(cls, INTERNALS_DICT)["flags"]
 
 
-def get_inst_fields(inst):
+def _get_inst_fields(inst):
+    # This is an internal helper for constructing new
+    # 'Field' instances from existing ones.
     return {
         k: getattr(inst, k)
         for k in get_fields(type(inst))
@@ -105,7 +92,7 @@ class MethodMaker:
         self.code_generator = code_generator
 
     def __repr__(self):
-        return f"<MethodMaker for {self.funcname} method>"
+        return f"<MethodMaker for {self.funcname!r} method>"
 
     def __get__(self, instance, cls):
         local_vars = {}
@@ -122,37 +109,52 @@ class MethodMaker:
         return method.__get__(instance, cls)
 
 
-def init_maker(cls, *, null=NOTHING):
-    fields = get_fields(cls)
-    flags = get_flags(cls)
+def get_init_maker(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)
-    code = f"def __init__(self, {args}):\n" f"    {assigns}\n"
-    return code, globs
+        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 cls_init_maker
+
+
+init_maker = get_init_maker()
 
 
 def repr_maker(cls):
@@ -189,11 +191,54 @@ def eq_maker(cls):
     return code, globs
 
 
+def frozen_setattr_maker(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_maker(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)
+frozen_setattr_desc = MethodMaker("__setattr__", frozen_setattr_maker)
+frozen_delattr_desc = MethodMaker("__delattr__", frozen_delattr_maker)
 default_methods = frozenset({init_desc, repr_desc, eq_desc})
 
 
@@ -255,6 +300,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"
@@ -300,7 +347,7 @@ class Field:
         :param kwargs: Additional keyword arguments for subclasses
         :return: new field subclass instance
         """
-        argument_dict = {**get_inst_fields(fld), **kwargs}
+        argument_dict = {**_get_inst_fields(fld), **kwargs}
 
         return cls(**argument_dict)
 
@@ -314,14 +361,19 @@ _field_internal = {
     "doc": Field(default=None),
 }
 
+_field_methods = {repr_desc, eq_desc}
+if _UNDER_TESTING:
+    _field_methods.update({frozen_setattr_desc, frozen_delattr_desc})
+
 builder(
     Field,
     gatherer=lambda cls_: _field_internal,
-    methods=frozenset({repr_desc, eq_desc}),
+    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):
@@ -337,46 +389,152 @@ class SlotFields(dict):
     """
 
 
-def slot_gatherer(cls):
+def make_slot_gatherer(field_type=Field):
+    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"
+            )
+
+        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
+
+        # Replace the SlotAttributes instance with a regular dict
+        # So that help() works
+        setattr(cls, "__slots__", slot_replacement)
+
+        # Update annotations with any types from the slots assignment
+        setattr(cls, "__annotations__", cls_annotations)
+        return cls_fields
+
+    return field_slot_gatherer
+
+
+slot_gatherer = make_slot_gatherer()
+
+
+# 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:
+            _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):
     """
-    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
+    :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.
     """
-    cls_slots = cls.__dict__.get("__slots__", None)
+    def field_annotation_gatherer(cls):
+        cls_annotations = cls.__dict__.get("__annotations__", {})
+
+        cls_fields: dict[str, field_type] = {}
+
+        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:
+                        setattr(cls, k, attrib.default)
+                    else:
+                        delattr(cls, k)
+                else:
+                    attrib = field_type(default=attrib, type=v)
+                    if not leave_default_values:
+                        delattr(cls, k)
 
-    if not isinstance(cls_slots, SlotFields):
-        raise TypeError(
-            "__slots__ must be an instance of SlotFields "
-            "in order to generate a slotclass"
-        )
+            else:
+                attrib = field_type(type=v)
 
-    cls_annotations = cls.__dict__.get("__annotations__", {})
-    cls_fields = {}
-    slot_replacement = {}
+            cls_fields[k] = attrib
+
+        return cls_fields
+
+    return field_annotation_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
-        else:
-            # Plain values treated as defaults
-            attrib = Field(default=v)
 
-        slot_replacement[k] = attrib.doc
-        cls_fields[k] = attrib
+annotation_gatherer = make_annotation_gatherer()
 
-    # Replace the SlotAttributes instance with a regular dict
-    # So that help() works
-    setattr(cls, "__slots__", slot_replacement)
 
-    # Update annotations with any types from the slots assignment
-    setattr(cls, "__annotations__", cls_annotations)
-    return cls_fields
+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.
@@ -393,43 +551,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 fieldclass(cls):
+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
+
+
+_field_init_desc = MethodMaker(
+    funcname="__init__",
+    code_generator=get_init_maker(
+        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)
 
-    # 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)
-        code += "    self.validate_field()\n"
-        return code, globs
+    field_methods = {_field_init_desc, repr_desc, eq_desc}
 
-    field_nothing = _NothingType()
-    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_desc, frozen_delattr_desc})
 
     cls = builder(
         cls,

ducktools/classbuilder/__init__.pyi

@@ -6,13 +6,11 @@ _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, *, 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]: ...
+def _get_inst_fields(inst: typing.Any) -> dict[str, typing.Any]: ...
 
 class _NothingType:
     ...
@@ -28,17 +26,24 @@ class MethodMaker:
     def __repr__(self) -> str: ...
     def __get__(self, instance, cls) -> Callable: ...
 
-def init_maker(
-    cls: type,
-    *,
+def get_init_maker(
     null: _NothingType = NOTHING,
-) -> tuple[str, dict[str, typing.Any]]: ...
+    extra_code: None | list[str] = None
+) -> Callable[[type], tuple[str, dict[str, typing.Any]]]: ...
+
+def init_maker(cls: type) -> tuple[str, dict[str, typing.Any]]: ...
 def repr_maker(cls: type) -> tuple[str, dict[str, typing.Any]]: ...
 def eq_maker(cls: type) -> tuple[str, dict[str, typing.Any]]: ...
 
+def frozen_setattr_maker(cls: type) -> tuple[str, dict[str, typing.Any]]: ...
+
+def frozen_delattr_maker(cls: type) -> tuple[str, dict[str, typing.Any]]: ...
+
 init_desc: MethodMaker
 repr_desc: MethodMaker
 eq_desc: MethodMaker
+frozen_setattr_desc: MethodMaker
+frozen_delattr_desc: MethodMaker
 default_methods: frozenset[MethodMaker]
 
 _T = typing.TypeVar("_T")
@@ -90,9 +95,22 @@ class Field:
 class SlotFields(dict):
     ...
 
+def make_slot_gatherer(field_type: type[Field] = Field) -> Callable[[type], dict[str, Field]]: ...
+
 def slot_gatherer(cls: type) -> dict[str, Field]:
     ...
 
+def is_classvar(hint: object) -> bool: ...
+
+def make_annotation_gatherer(
+    field_type: type[Field] = Field,
+    leave_default_values: bool = True,
+) -> Callable[[type], dict[str, Field]]: ...
+
+def annotation_gatherer(cls: type) -> dict[str, Field]: ...
+
+def check_argument_order(cls: type) -> None: ...
+
 @typing.overload
 def slotclass(
     cls: type[_T],
@@ -111,4 +129,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_desc, frozen_delattr_desc, 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)
@@ -414,8 +350,6 @@ 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()
 
 
@@ -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
@@ -519,7 +448,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,37 +462,43 @@ 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)
                 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]
+            delattr(cls, name)  # clear attrib from class
 
             # 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
 

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_internals, slot_gatherer
+    builder, fieldclass, get_flags, get_fields, 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,10 +36,6 @@ 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: ...
 
 
@@ -51,8 +45,6 @@ repr_desc: MethodMaker
 recursive_repr_desc: MethodMaker
 eq_desc: MethodMaker
 iter_desc: MethodMaker
-frozen_setattr_desc: MethodMaker
-frozen_delattr_desc: MethodMaker
 asdict_desc: MethodMaker
 
 class Attribute(Field):

{ducktools_classbuilder-0.2.1.dist-info → ducktools_classbuilder-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ducktools-classbuilder
-Version: 0.2.1
+Version: 0.4.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 #
 
@@ -121,7 +122,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 +207,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 +238,10 @@ It will copy values provided as the `type` to `Field` into the
 Values provided to `doc` will be placed in the final `__slots__` 
 field so they are present on the class if `help(...)` is called.
 
+A fairly basic `annotations_gatherer` and `annotationclass` are included
+in `extras.py` which can be used to generate classbuilders that rely on 
+annotations.
+
 If you want something with more features you can look at the `prefab.py`
 implementation which provides a 'prebuilt' implementation.
 

ducktools_classbuilder-0.4.0.dist-info/RECORD

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

ducktools_classbuilder-0.2.1.dist-info/RECORD

@@ -1,10 +0,0 @@
-ducktools/classbuilder/__init__.py,sha256=yZOiy84vo8z0iotOgY1rFwBBngveh1cwoWjcQdRndpw,13747
-ducktools/classbuilder/__init__.pyi,sha256=-QHJhPn4EjI4XW4OI74MKNg2tGKJiM3w0ELSOvPstAw,2877
-ducktools/classbuilder/prefab.py,sha256=gJJCtTAbQLgIoo79jRWVp09r3u8kJjcqXp4G4FTu9j8,29887
-ducktools/classbuilder/prefab.pyi,sha256=GsllqqZ_Wz6i_DenKv-pAbtES3sPanC0g8O7fkNTnvs,3969
-ducktools/classbuilder/py.typed,sha256=la67KBlbjXN-_-DfGNcdOcjYumVpKG_Tkw-8n5dnGB4,8
-ducktools_classbuilder-0.2.1.dist-info/LICENSE.md,sha256=6Thz9Dbw8R4fWInl6sGl8Rj3UnKnRbDwrc6jZerpugQ,1070
-ducktools_classbuilder-0.2.1.dist-info/METADATA,sha256=kV--mUdR1y0NmszwMobZdnNvigtepG_WF_axupjf6_4,9280
-ducktools_classbuilder-0.2.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-ducktools_classbuilder-0.2.1.dist-info/top_level.txt,sha256=uSDLtio3ZFqdwcsMJ2O5yhjB4Q3ytbBWbA8rJREganc,10
-ducktools_classbuilder-0.2.1.dist-info/RECORD,,