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

ducktools/classbuilder/prefab.py

@@ -25,33 +25,25 @@ A 'prebuilt' implementation of class generation.
 
 Includes pre and post init functions along with other methods.
 """
-
-import sys
-
 from . import (
     INTERNALS_DICT, NOTHING,
-    Field, MethodMaker, SlotFields,
-    builder, fieldclass, get_flags, get_fields, make_slot_gatherer,
-    frozen_setattr_maker, frozen_delattr_maker, is_classvar,
+    Field, MethodMaker, GatheredFields, GeneratedCode, SlotMakerMeta,
+    builder, get_flags, get_fields,
+    make_unified_gatherer,
+    frozen_setattr_maker, frozen_delattr_maker, eq_maker,
+    get_repr_generator,
 )
 
+# These aren't used but are re-exported for ease of use
+# noinspection PyUnresolvedReferences
+from . import SlotFields, KW_ONLY
+
 PREFAB_FIELDS = "PREFAB_FIELDS"
 PREFAB_INIT_FUNC = "__prefab_init__"
 PRE_INIT_FUNC = "__prefab_pre_init__"
 POST_INIT_FUNC = "__prefab_post_init__"
 
 
-# KW_ONLY sentinel 'type' to use to indicate all subsequent attributes are
-# keyword only
-# noinspection PyPep8Naming
-class _KW_ONLY_TYPE:
-    def __repr__(self):
-        return "<KW_ONLY Sentinel Object>"
-
-
-KW_ONLY = _KW_ONLY_TYPE()
-
-
 class PrefabError(Exception):
     pass
 
@@ -69,7 +61,7 @@ def get_attributes(cls):
 
 # Method Generators
 def get_init_maker(*, init_name="__init__"):
-    def __init__(cls: "type") -> "tuple[str, dict]":
+    def __init__(cls: type) -> GeneratedCode:
         globs = {}
         # Get the internals dictionary and prepare attributes
         attributes = get_attributes(cls)
@@ -218,100 +210,18 @@ def get_init_maker(*, init_name="__init__"):
             f"{body}\n"
             f"{post_init_call}\n"
         )
-        return code, globs
+        return GeneratedCode(code, globs)
 
     return MethodMaker(init_name, __init__)
 
 
-def get_repr_maker(*, recursion_safe=False):
-    def __repr__(cls: "type") -> "tuple[str, dict]":
-        attributes = get_attributes(cls)
-
-        globs = {}
-
-        will_eval = True
-        valid_names = []
-        for name, attrib in attributes.items():
-            if attrib.repr and not attrib.exclude_field:
-                valid_names.append(name)
-
-            # If the init fields don't match the repr, or some fields are excluded
-            # generate a repr that clearly will not evaluate
-            if will_eval and (attrib.exclude_field or (attrib.init ^ attrib.repr)):
-                will_eval = False
-
-        content = ", ".join(
-            f"{name}={{self.{name}!r}}"
-            for name in valid_names
-        )
-
-        if recursion_safe:
-            import reprlib
-            globs["_recursive_repr"] = reprlib.recursive_repr()
-            recursion_func = "@_recursive_repr\n"
-        else:
-            recursion_func = ""
-
-        if will_eval:
-            code = (
-                f"{recursion_func}"
-                f"def __repr__(self):\n"
-                f"    return f'{{type(self).__qualname__}}({content})'\n"
-            )
-        else:
-            if content:
-                code = (
-                    f"{recursion_func}"
-                    f"def __repr__(self):\n"
-                    f"    return f'<prefab {{type(self).__qualname__}}; {content}>'\n"
-                )
-            else:
-                code = (
-                    f"{recursion_func}"
-                    f"def __repr__(self):\n"
-                    f"    return f'<prefab {{type(self).__qualname__}}>'\n"
-                )
-
-        return code, globs
-
-    return MethodMaker("__repr__", __repr__)
-
-
-def get_eq_maker():
-    def __eq__(cls: "type") -> "tuple[str, dict]":
-        class_comparison = "self.__class__ is other.__class__"
-        attribs = get_attributes(cls)
-        field_names = [
-            name
-            for name, attrib in attribs.items()
-            if attrib.compare and not attrib.exclude_field
-        ]
-
-        if field_names:
-            selfvals = ",".join(f"self.{name}" for name in field_names)
-            othervals = ",".join(f"other.{name}" for name in field_names)
-            instance_comparison = f"({selfvals},) == ({othervals},)"
-        else:
-            instance_comparison = "True"
-
-        code = (
-            f"def __eq__(self, other):\n"
-            f"    return {instance_comparison} if {class_comparison} else NotImplemented\n"
-        )
-        globs = {}
-
-        return code, globs
-
-    return MethodMaker("__eq__", __eq__)
-
-
 def get_iter_maker():
-    def __iter__(cls: "type") -> "tuple[str, dict]":
+    def __iter__(cls: type) -> GeneratedCode:
         fields = get_attributes(cls)
 
         valid_fields = (
             name for name, attrib in fields.items()
-            if attrib.iter and not attrib.exclude_field
+            if attrib.iter
         )
 
         values = "\n".join(f"    yield self.{name}" for name in valid_fields)
@@ -322,56 +232,61 @@ def get_iter_maker():
 
         code = f"def __iter__(self):\n{values}"
         globs = {}
-        return code, globs
+        return GeneratedCode(code, globs)
 
     return MethodMaker("__iter__", __iter__)
 
 
 def get_asdict_maker():
-    def as_dict_gen(cls: "type") -> "tuple[str, dict]":
+    def as_dict_gen(cls: type) -> GeneratedCode:
         fields = get_attributes(cls)
 
         vals = ", ".join(
             f"'{name}': self.{name}"
             for name, attrib in fields.items()
-            if attrib.serialize and not attrib.exclude_field
+            if attrib.serialize
         )
         out_dict = f"{{{vals}}}"
         code = f"def as_dict(self): return {out_dict}"
 
         globs = {}
-        return code, globs
+        return GeneratedCode(code, globs)
     return MethodMaker("as_dict", as_dict_gen)
 
 
 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()
+repr_maker = MethodMaker(
+    "__repr__",
+    get_repr_generator(recursion_safe=False, eval_safe=True)
+)
+recursive_repr_maker = MethodMaker(
+    "__repr__",
+    get_repr_generator(recursion_safe=True, eval_safe=True)
+)
 iter_maker = get_iter_maker()
 asdict_maker = get_asdict_maker()
 
 
 # Updated field with additional attributes
-@fieldclass
 class Attribute(Field):
-    __slots__ = SlotFields(
-        init=True,
-        repr=True,
-        compare=True,
-        iter=True,
-        kw_only=False,
-        serialize=True,
-        exclude_field=False,
-    )
+    """
+    Get an object to define a prefab attribute
 
-    def validate_field(self):
-        super().validate_field()
-        if self.kw_only and not self.init:
-            raise PrefabError(
-                "Attribute cannot be keyword only if it is not in init."
-            )
+    :param default: Default value for this attribute
+    :param default_factory: 0 argument callable to give a default value
+                            (for otherwise mutable defaults, eg: list)
+    :param init: Include this attribute in the __init__ parameters
+    :param repr: Include this attribute in the class __repr__
+    :param compare: Include this attribute in the class __eq__
+    :param iter: Include this attribute in the class __iter__ if generated
+    :param kw_only: Make this argument keyword only in init
+    :param serialize: Include this attribute in methods that serialize to dict
+    :param doc: Parameter documentation for slotted classes
+    :param type: Type of this attribute (for slotted classes)
+    """
+    iter: bool = True
+    serialize: bool = True
 
 
 # noinspection PyShadowingBuiltins
@@ -390,7 +305,7 @@ def attribute(
     type=NOTHING,
 ):
     """
-    Get an object to define a prefab Attribute
+    Helper function to get an object to define a prefab Attribute
 
     :param default: Default value for this attribute
     :param default_factory: 0 argument callable to give a default value
@@ -401,15 +316,18 @@ def attribute(
     :param iter: Include this attribute in the class __iter__ if generated
     :param kw_only: Make this argument keyword only in init
     :param serialize: Include this attribute in methods that serialize to dict
-    :param exclude_field: Exclude this field from all magic method generation
-                          apart from __init__ signature
-                          and do not include it in PREFAB_FIELDS
-                          Must be assigned in __prefab_post_init__
+    :param exclude_field: Shorthand for setting repr, compare, iter and serialize to False
     :param doc: Parameter documentation for slotted classes
     :param type: Type of this attribute (for slotted classes)
 
     :return: Attribute generated with these parameters.
     """
+    if exclude_field:
+        repr = False
+        compare = False
+        iter = False
+        serialize = False
+
     return Attribute(
         default=default,
         default_factory=default_factory,
@@ -419,90 +337,12 @@ def attribute(
         iter=iter,
         kw_only=kw_only,
         serialize=serialize,
-        exclude_field=exclude_field,
         doc=doc,
         type=type,
     )
 
 
-slot_prefab_gatherer = make_slot_gatherer(Attribute)
-
-
-# Gatherer for classes built on attributes or annotations
-def attribute_gatherer(cls):
-    cls_annotations = cls.__dict__.get("__annotations__", {})
-    cls_annotation_names = cls_annotations.keys()
-
-    cls_slots = cls.__dict__.get("__slots__", {})
-
-    cls_attributes = {
-        k: v for k, v in vars(cls).items() if isinstance(v, Attribute)
-    }
-
-    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.
-        kw_flag = False
-        new_attributes = {}
-        for name, value in cls_annotations.items():
-            # Ignore ClassVar hints
-            if is_classvar(value):
-                continue
-
-            # Look for the KW_ONLY annotation
-            if value is KW_ONLY or value == "KW_ONLY":
-                if kw_flag:
-                    raise PrefabError(
-                        "Class can not be defined as keyword only twice"
-                    )
-                kw_flag = True
-            else:
-                # 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 = Attribute.from_field(
-                            cls_attributes[name],
-                            **extras,
-                        )
-                    else:
-                        attribute_default = getattr(cls, name)
-                        attrib = attribute(default=attribute_default, **extras)
-
-                    # Clear the attribute from the class after it has been used
-                    # in the definition.
-                    cls_modifications[name] = NOTHING
-                else:
-                    attrib = attribute(**extras)
-
-                new_attributes[name] = attrib
-
-        cls_attributes = new_attributes
-    else:
-        for name in cls_attributes.keys():
-            attrib = cls_attributes[name]
-            cls_modifications[name] = NOTHING
-
-            # Some items can still be annotated.
-            if name in cls_annotations:
-                new_attrib = Attribute.from_field(attrib, type=cls_annotations[name])
-                cls_attributes[name] = new_attrib
-
-    return cls_attributes, cls_modifications
+prefab_gatherer = make_unified_gatherer(Attribute, False)
 
 
 # Class Builders
@@ -519,6 +359,7 @@ def _make_prefab(
     frozen=False,
     dict_method=False,
     recursive_repr=False,
+    gathered_fields=None,
 ):
     """
     Generate boilerplate code for dunder methods in a class.
@@ -535,6 +376,7 @@ def _make_prefab(
                    such as lists)
     :param dict_method: Include an as_dict method for faster dictionary creation
     :param recursive_repr: Safely handle repr in case of recursion
+    :param gathered_fields: Pre-gathered fields callable, to skip re-collecting attributes
     :return: class with __ methods defined
     """
     cls_dict = cls.__dict__
@@ -546,12 +388,13 @@ def _make_prefab(
         )
 
     slots = cls_dict.get("__slots__")
-    if isinstance(slots, SlotFields):
-        gatherer = slot_prefab_gatherer
-        slotted = True
+
+    slotted = False if slots is None else True
+
+    if gathered_fields is None:
+        gatherer = prefab_gatherer
     else:
-        gatherer = attribute_gatherer
-        slotted = False
+        gatherer = gathered_fields
 
     methods = set()
 
@@ -651,9 +494,9 @@ def _make_prefab(
         post_init_args.extend(arglist)
 
     # Gather values for match_args and do some syntax checking
-
     default_defined = []
-    valid_args = []
+    valid_args = list(fields.keys())
+
     for name, attrib in fields.items():
         # slot_gather and parent classes may use Fields
         # prefabs require Attributes, so convert.
@@ -661,15 +504,6 @@ def _make_prefab(
             attrib = Attribute.from_field(attrib)
             fields[name] = attrib
 
-        # Excluded fields *MUST* be forwarded to post_init
-        if attrib.exclude_field:
-            if name not in post_init_args:
-                raise PrefabError(
-                    f"{name!r} is an excluded attribute but is not passed to post_init"
-                )
-        else:
-            valid_args.append(name)
-
         if not kw_only:
             # Syntax check arguments for __init__ don't have non-default after default
             if attrib.init and not attrib.kw_only:
@@ -692,6 +526,37 @@ def _make_prefab(
     return cls
 
 
+class Prefab(metaclass=SlotMakerMeta):
+    _meta_gatherer = prefab_gatherer
+    __slots__ = {}
+
+    # noinspection PyShadowingBuiltins
+    def __init_subclass__(
+        cls,
+        init=True,
+        repr=True,
+        eq=True,
+        iter=False,
+        match_args=True,
+        kw_only=False,
+        frozen=False,
+        dict_method=False,
+        recursive_repr=False,
+    ):
+        _make_prefab(
+            cls,
+            init=init,
+            repr=repr,
+            eq=eq,
+            iter=iter,
+            match_args=match_args,
+            kw_only=kw_only,
+            frozen=frozen,
+            dict_method=dict_method,
+            recursive_repr=recursive_repr,
+        )
+
+
 # noinspection PyShadowingBuiltins
 def prefab(
     cls=None,
@@ -770,6 +635,7 @@ def build_prefab(
     frozen=False,
     dict_method=False,
     recursive_repr=False,
+    slots=False,
 ):
     """
     Dynamically construct a (dynamic) prefab.
@@ -790,12 +656,35 @@ def build_prefab(
                    (This does not prevent the modification of mutable attributes such as lists)
     :param dict_method: Include an as_dict method for faster dictionary creation
     :param recursive_repr: Safely handle repr in case of recursion
+    :param slots: Make the resulting class slotted
     :return: class with __ methods defined
     """
-    class_dict = {} if class_dict is None else class_dict
-    cls = type(class_name, bases, class_dict)
+    class_dict = {} if class_dict is None else class_dict.copy()
+
+    class_annotations = {}
+    class_slots = {}
+    fields = {}
+
     for name, attrib in attributes:
-        setattr(cls, name, attrib)
+        if isinstance(attrib, Attribute):
+            fields[name] = attrib
+        elif isinstance(attrib, Field):
+            fields[name] = Attribute.from_field(attrib)
+        else:
+            fields[name] = Attribute(default=attrib)
+
+        if attrib.type is not NOTHING:
+            class_annotations[name] = attrib.type
+
+        class_slots[name] = attrib.doc
+
+    if slots:
+        class_dict["__slots__"] = class_slots
+
+    class_dict["__annotations__"] = class_annotations
+    cls = type(class_name, bases, class_dict)
+
+    gathered_fields = GatheredFields(fields, {})
 
     cls = _make_prefab(
         cls,
@@ -808,6 +697,7 @@ def build_prefab(
         frozen=frozen,
         dict_method=dict_method,
         recursive_repr=recursive_repr,
+        gathered_fields=gathered_fields,
     )
 
     return cls
@@ -864,5 +754,5 @@ def as_dict(o):
     return {
         name: getattr(o, name)
         for name, attrib in flds.items()
-        if attrib.serialize and not attrib.exclude_field
+        if attrib.serialize
     }

ducktools/classbuilder/prefab.pyi

@@ -1,14 +1,18 @@
 import typing
+from types import MappingProxyType
 from typing_extensions import dataclass_transform
 
 from collections.abc import Callable
 
 from . import (
-    INTERNALS_DICT, NOTHING,
-    Field, MethodMaker, SlotFields as SlotFields,
-    builder, fieldclass, get_flags, get_fields, make_slot_gatherer
+    NOTHING,
+    Field,
+    MethodMaker,
+    SlotMakerMeta,
 )
 
+from . import SlotFields as SlotFields, KW_ONLY as KW_ONLY
+
 # noinspection PyUnresolvedReferences
 from . import _NothingType
 
@@ -17,12 +21,7 @@ PREFAB_INIT_FUNC: str
 PRE_INIT_FUNC: str
 POST_INIT_FUNC: str
 
-
-# noinspection PyPep8Naming
-class _KW_ONLY_TYPE:
-    def __repr__(self) -> str: ...
-
-KW_ONLY: _KW_ONLY_TYPE
+_CopiableMappings = dict[str, typing.Any] | MappingProxyType[str, typing.Any]
 
 class PrefabError(Exception): ...
 
@@ -30,10 +29,6 @@ def get_attributes(cls: type) -> dict[str, Attribute]: ...
 
 def get_init_maker(*, init_name: str="__init__") -> MethodMaker: ...
 
-def get_repr_maker(*, recursion_safe: bool = False) -> MethodMaker: ...
-
-def get_eq_maker() -> MethodMaker: ...
-
 def get_iter_maker() -> MethodMaker: ...
 
 def get_asdict_maker() -> MethodMaker: ...
@@ -50,13 +45,8 @@ asdict_maker: MethodMaker
 class Attribute(Field):
     __slots__: dict
 
-    init: bool
-    repr: bool
-    compare: bool
     iter: bool
-    kw_only: bool
     serialize: bool
-    exclude_field: bool
 
     def __init__(
         self,
@@ -71,7 +61,6 @@ class Attribute(Field):
         iter: bool = True,
         kw_only: bool = False,
         serialize: bool = True,
-        exclude_field: bool = False,
     ) -> None: ...
 
     def __repr__(self) -> str: ...
@@ -93,9 +82,7 @@ def attribute(
     exclude_field: bool = False,
 ) -> Attribute: ...
 
-def slot_prefab_gatherer(cls: type) -> tuple[dict[str, Attribute], dict[str, typing.Any]]: ...
-
-def attribute_gatherer(cls: type) -> tuple[dict[str, Attribute], dict[str, typing.Any]]: ...
+def prefab_gatherer(cls_or_ns: type | MappingProxyType) -> tuple[dict[str, Attribute], dict[str, typing.Any]]: ...
 
 def _make_prefab(
     cls: type,
@@ -109,10 +96,28 @@ def _make_prefab(
     frozen: bool = False,
     dict_method: bool = False,
     recursive_repr: bool = False,
+    gathered_fields: Callable[[type], tuple[dict[str, Attribute], dict[str, typing.Any]]] | None = None,
 ) -> type: ...
 
 _T = typing.TypeVar("_T")
 
+# noinspection PyUnresolvedReferences
+@dataclass_transform(field_specifiers=(Attribute, attribute))
+class Prefab(metaclass=SlotMakerMeta):
+    _meta_gatherer: Callable[[type | _CopiableMappings], tuple[dict[str, Field], dict[str, typing.Any]]]
+    def __init_subclass__(
+        cls,
+        init: bool = True,
+        repr: bool = True,
+        eq: bool = True,
+        iter: bool = False,
+        match_args: bool = True,
+        kw_only: bool = False,
+        frozen: bool = False,
+        dict_method: bool = False,
+        recursive_repr: bool = False,
+    ) -> None: ...
+
 
 # For some reason PyCharm can't see 'attribute'?!?
 # noinspection PyUnresolvedReferences
@@ -146,6 +151,7 @@ def build_prefab(
     frozen: bool = False,
     dict_method: bool = False,
     recursive_repr: bool = False,
+    slots: bool = False,
 ) -> type: ...
 
 def is_prefab(o: typing.Any) -> bool: ...