ducktools-classbuilder 0.7.0__tar.gz → 0.7.2__tar.gz

{ducktools_classbuilder-0.7.0 → ducktools_classbuilder-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ducktools-classbuilder
-Version: 0.7.0
+Version: 0.7.2
 Summary: Toolkit for creating class boilerplate generators
 Author: David C Ellis
 License: MIT License
@@ -32,6 +32,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Operating System :: OS Independent
 Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.8

{ducktools_classbuilder-0.7.0 → ducktools_classbuilder-0.7.2}/docs/extension_examples.md

@@ -84,7 +84,7 @@ def iter_generator(cls, funcname="__iter__"):
     field_yield = "\n".join(f"    yield self.{f}" for f in field_names)
     if not field_yield:
         field_yield = "    yield from ()"
-    code = f"def {funcname}(self):\n" f"{field_yield}"
+    code = f"def {funcname}(self):\n{field_yield}"
     globs = {}
     return GeneratedCode(code, globs)
 
@@ -259,6 +259,138 @@ if __name__ == "__main__":
         print(e)
 ```
 
+#### Frozen Attributes ####
+
+Here's an implementation that allows freezing of individual attributes.
+
+```python
+import ducktools.classbuilder as dtbuild
+
+
+class FreezableField(dtbuild.Field):
+    frozen: bool = False
+
+
+def setattr_generator(cls, funcname="__setattr__"):
+    globs = {}
+
+    flags = dtbuild.get_flags(cls)
+    fields = dtbuild.get_fields(cls)
+
+    frozen_fields = set(
+        name for name, field in fields.items()
+        if getattr(field, "frozen", False)
+    )
+
+    globs["__frozen_fields"] = frozen_fields
+
+    if flags.get("slotted", True):
+        globs["__setattr_func"] = object.__setattr__
+        setattr_method = "__setattr_func(self, name, value)"
+        attrib_check = "hasattr(self, name)"
+    else:
+        setattr_method = "self.__dict__[name] = value"
+        attrib_check = "name in self.__dict__"
+
+    code = (
+        f"def {funcname}(self, name, value):\n"
+        f"    if name in __frozen_fields and {attrib_check}:\n"
+        f"        raise AttributeError(\n"
+        f"            f'Attribute {{name!r}} does not support assignment'\n"
+        f"        )\n"
+        f"    else:\n"
+        f"        {setattr_method}\n"
+    )
+
+    return dtbuild.GeneratedCode(code, globs)
+
+
+def delattr_generator(cls, funcname="__delattr__"):
+    globs = {}
+
+    flags = dtbuild.get_flags(cls)
+    fields = dtbuild.get_fields(cls)
+
+    frozen_fields = set(
+        name for name, field in fields.items()
+        if getattr(field, "frozen", False)
+    )
+
+    globs["__frozen_fields"] = frozen_fields
+
+    if flags.get("slotted", True):
+        globs["__delattr_func"] = object.__delattr__
+        delattr_method = "__delattr_func(self, name)"
+    else:
+        delattr_method = "del self.__dict__[name]"
+
+    code = (
+        f"def {funcname}(self, name):\n"
+        f"    if name in __frozen_fields:"
+        f"        raise AttributeError(\n"
+        f"            f'Attribute {{name!r}} is frozen and can not be deleted'\n"
+        f"        )\n"
+        f"    else:\n"
+        f"        {delattr_method}\n"
+    )
+
+    return dtbuild.GeneratedCode(code, globs)
+
+
+frozen_setattr_field_maker = dtbuild.MethodMaker("__setattr__", setattr_generator)
+frozen_delattr_field_maker = dtbuild.MethodMaker("__delattr__", delattr_generator)
+gatherer = dtbuild.make_unified_gatherer(FreezableField)
+
+
+def freezable(cls=None, /, *, frozen=False):
+    if cls is None:
+        return lambda cls_: freezable(cls_, frozen=frozen)
+
+    # To make a slotted class use a base class with metaclass
+    flags = {"frozen": frozen, "slotted": False}
+
+    cls = dtbuild.builder(
+        cls,
+        gatherer=gatherer,
+        methods=dtbuild.default_methods,
+        flags=flags,
+    )
+
+    # Frozen attributes need to be added afterwards
+    # Due to the need to know if frozen fields exist
+    if frozen:
+        setattr(cls, "__setattr__", dtbuild.frozen_setattr_maker)
+        setattr(cls, "__delattr__", dtbuild.frozen_delattr_maker)
+    else:
+        fields = dtbuild.get_fields(cls)
+        has_frozen_fields = False
+        for f in fields.values():
+            if getattr(f, "frozen", False):
+                has_frozen_fields = True
+                break
+
+        if has_frozen_fields:
+            setattr(cls, "__setattr__", frozen_setattr_field_maker)
+            setattr(cls, "__delattr__", frozen_delattr_field_maker)
+
+    return cls
+
+
+@freezable
+class X:
+    a: int = 2
+    b: int = FreezableField(default=12, frozen=True)
+
+
+x = X()
+x.a = 21
+
+try:
+    x.b = 43
+except AttributeError as e:
+    print(repr(e))
+```
+
 #### Converters ####
 
 Here's an implementation of basic converters that always convert when
@@ -330,7 +462,7 @@ if __name__ == "__main__":
 
 This seems to be a feature people keep requesting for `dataclasses`.
 
-To implement this you simply need to create a new annotated_gatherer function.
+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.

{ducktools_classbuilder-0.7.0 → ducktools_classbuilder-0.7.2}/docs/tutorial.md

@@ -1,6 +1,6 @@
 # Tutorial: Making a class boilerplate generator #
 
-The core idea is that there are 3 parts to the process of generating
+The core idea is that there are 4 parts to the process of generating
 the class boilerplate that need to be handled:
 
 1. Create a new subclass of `Field` if you need to add any extra attributes to fields
@@ -162,7 +162,7 @@ print(report_generator(CodegenDemo).source_code)
 Here we will make both a simple decorator based builder and then a subclass
 based builder that can create `__slots__`.
 
-### Decorator builder ###
+### 4a: Decorator builder ###
 ```python
 def reportclass(cls):
     gatherer = fields_attribute_gatherer
@@ -177,21 +177,22 @@ def reportclass(cls):
     flags = {"slotted": slotted}
 
     return dtbuild.builder(cls, gatherer=gatherer, methods=methods, flags=flags)
+```
 
-# Step 4b: Define a base class builder
+### 4b: Base class Builder ###
+```python
 # Once slots have been made, slot_gatherer should be used.
 slot_gatherer = dtbuild.make_slot_gatherer(CustomField)
-```
 
-### Base class Builder ###
-```python
+
 class ReportClass(metaclass=dtbuild.SlotMakerMeta):
     __slots__ = {}
     _meta_gatherer = fields_attribute_gatherer
 
     def __init_subclass__(cls):
-        slotted = '__slots__' in vars(cls) and isinstance(cls.__slots__, dtbuild.SlotFields)
-        gatherer = slot_gatherer if slotted else fields_attribute_gatherer
+        # Check if the metaclass has generated slots
+        meta_slotted = '__slots__' in vars(cls) and isinstance(cls.__slots__, dtbuild.SlotFields)
+        gatherer = slot_gatherer if meta_slotted else fields_attribute_gatherer
         methods = {
             dtbuild.eq_maker,
             dtbuild.repr_maker,
@@ -199,6 +200,7 @@ class ReportClass(metaclass=dtbuild.SlotMakerMeta):
             report_maker
         }
 
+        # The class may still have slots unrelated to code generation
         slotted = "__slots__" in vars(cls)
         flags = {"slotted": slotted}
 

ducktools_classbuilder-0.7.2/docs_code/docs_ex10_frozen_attributes.py

@@ -0,0 +1,125 @@
+import ducktools.classbuilder as dtbuild
+
+
+class FreezableField(dtbuild.Field):
+    frozen: bool = False
+
+
+def setattr_generator(cls, funcname="__setattr__"):
+    globs = {}
+
+    flags = dtbuild.get_flags(cls)
+    fields = dtbuild.get_fields(cls)
+
+    frozen_fields = set(
+        name for name, field in fields.items()
+        if getattr(field, "frozen", False)
+    )
+
+    globs["__frozen_fields"] = frozen_fields
+
+    if flags.get("slotted", True):
+        globs["__setattr_func"] = object.__setattr__
+        setattr_method = "__setattr_func(self, name, value)"
+        attrib_check = "hasattr(self, name)"
+    else:
+        setattr_method = "self.__dict__[name] = value"
+        attrib_check = "name in self.__dict__"
+
+    code = (
+        f"def {funcname}(self, name, value):\n"
+        f"    if name in __frozen_fields and {attrib_check}:\n"
+        f"        raise AttributeError(\n"
+        f"            f'Attribute {{name!r}} does not support assignment'\n"
+        f"        )\n"
+        f"    else:\n"
+        f"        {setattr_method}\n"
+    )
+
+    return dtbuild.GeneratedCode(code, globs)
+
+
+def delattr_generator(cls, funcname="__delattr__"):
+    globs = {}
+
+    flags = dtbuild.get_flags(cls)
+    fields = dtbuild.get_fields(cls)
+
+    frozen_fields = set(
+        name for name, field in fields.items()
+        if getattr(field, "frozen", False)
+    )
+
+    globs["__frozen_fields"] = frozen_fields
+
+    if flags.get("slotted", True):
+        globs["__delattr_func"] = object.__delattr__
+        delattr_method = "__delattr_func(self, name)"
+    else:
+        delattr_method = "del self.__dict__[name]"
+
+    code = (
+        f"def {funcname}(self, name):\n"
+        f"    if name in __frozen_fields:"
+        f"        raise AttributeError(\n"
+        f"            f'Attribute {{name!r}} is frozen and can not be deleted'\n"
+        f"        )\n"
+        f"    else:\n"
+        f"        {delattr_method}\n"
+    )
+
+    return dtbuild.GeneratedCode(code, globs)
+
+
+frozen_setattr_field_maker = dtbuild.MethodMaker("__setattr__", setattr_generator)
+frozen_delattr_field_maker = dtbuild.MethodMaker("__delattr__", delattr_generator)
+gatherer = dtbuild.make_unified_gatherer(FreezableField)
+
+
+def freezable(cls=None, /, *, frozen=False):
+    if cls is None:
+        return lambda cls_: freezable(cls_, frozen=frozen)
+
+    # To make a slotted class use a base class with metaclass
+    flags = {"frozen": frozen, "slotted": False}
+
+    cls = dtbuild.builder(
+        cls,
+        gatherer=gatherer,
+        methods=dtbuild.default_methods,
+        flags=flags,
+    )
+
+    # Frozen attributes need to be added afterwards
+    # Due to the need to know if frozen fields exist
+    if frozen:
+        setattr(cls, "__setattr__", dtbuild.frozen_setattr_maker)
+        setattr(cls, "__delattr__", dtbuild.frozen_delattr_maker)
+    else:
+        fields = dtbuild.get_fields(cls)
+        has_frozen_fields = False
+        for f in fields.values():
+            if getattr(f, "frozen", False):
+                has_frozen_fields = True
+                break
+
+        if has_frozen_fields:
+            setattr(cls, "__setattr__", frozen_setattr_field_maker)
+            setattr(cls, "__delattr__", frozen_delattr_field_maker)
+
+    return cls
+
+
+@freezable
+class X:
+    a: int = 2
+    b: int = FreezableField(default=12, frozen=True)
+
+
+x = X()
+x.a = 21
+
+try:
+    x.b = 43
+except AttributeError as e:
+    print(repr(e))

{ducktools_classbuilder-0.7.0 → ducktools_classbuilder-0.7.2}/docs_code/docs_ex3_iterable.py

@@ -13,7 +13,7 @@ def iter_generator(cls, funcname="__iter__"):
     field_yield = "\n".join(f"    yield self.{f}" for f in field_names)
     if not field_yield:
         field_yield = "    yield from ()"
-    code = f"def {funcname}(self):\n" f"{field_yield}"
+    code = f"def {funcname}(self):\n{field_yield}"
     globs = {}
     return GeneratedCode(code, globs)
 

{ducktools_classbuilder-0.7.0 → ducktools_classbuilder-0.7.2}/docs_code/tutorial_code.py

@@ -117,8 +117,9 @@ class ReportClass(metaclass=dtbuild.SlotMakerMeta):
     _meta_gatherer = fields_attribute_gatherer
 
     def __init_subclass__(cls):
-        slotted = '__slots__' in vars(cls) and isinstance(cls.__slots__, dtbuild.SlotFields)
-        gatherer = slot_gatherer if slotted else fields_attribute_gatherer
+        # Check if the metaclass has generated slots
+        meta_slotted = '__slots__' in vars(cls) and isinstance(cls.__slots__, dtbuild.SlotFields)
+        gatherer = slot_gatherer if meta_slotted else fields_attribute_gatherer
         methods = {
             dtbuild.eq_maker,
             dtbuild.repr_maker,
@@ -126,6 +127,7 @@ class ReportClass(metaclass=dtbuild.SlotMakerMeta):
             report_maker
         }
 
+        # The class may still have slots unrelated to code generation
         slotted = "__slots__" in vars(cls)
         flags = {"slotted": slotted}
 

{ducktools_classbuilder-0.7.0 → ducktools_classbuilder-0.7.2}/pyproject.toml

@@ -20,6 +20,7 @@ classifiers = [
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Operating System :: OS Independent",
     "License :: OSI Approved :: MIT License",
 ]

{ducktools_classbuilder-0.7.0 → ducktools_classbuilder-0.7.2}/src/ducktools/classbuilder/__init__.py

@@ -363,15 +363,17 @@ def eq_generator(cls, funcname="__eq__"):
     ]
 
     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},)"
+        instance_comparison = "\n        and ".join(
+            f"self.{name} == other.{name}" for name in field_names
+        )
     else:
         instance_comparison = "True"
 
     code = (
         f"def {funcname}(self, other):\n"
-        f"    return {instance_comparison} if {class_comparison} else NotImplemented\n"
+        f"    return (\n"
+        f"        {instance_comparison}\n"
+        f"    ) if {class_comparison} else NotImplemented\n"
     )
     globs = {}
 
@@ -390,11 +392,13 @@ def frozen_setattr_generator(cls, funcname="__setattr__"):
     if flags.get("slotted", True):
         globs["__setattr_func"] = object.__setattr__
         setattr_method = "__setattr_func(self, name, value)"
+        hasattr_check = "hasattr(self, name)"
     else:
         setattr_method = "self.__dict__[name] = value"
+        hasattr_check = "name in self.__dict__"
 
     body = (
-        f"    if hasattr(self, name) or name not in __field_names:\n"
+        f"    if {hasattr_check} 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'
@@ -707,10 +711,6 @@ def make_slot_gatherer(field_type=Field):
                 "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 = get_ns_annotations(cls_dict)
-
         cls_fields = {}
         slot_replacement = {}
 
@@ -724,8 +724,6 @@ def make_slot_gatherer(field_type=Field):
 
             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)
@@ -738,7 +736,6 @@ def make_slot_gatherer(field_type=Field):
         # In this case, slots with documentation and new annotations.
         modifications = {
             "__slots__": slot_replacement,
-            "__annotations__": cls_annotations,
         }
 
         return cls_fields, modifications
@@ -748,7 +745,7 @@ def make_slot_gatherer(field_type=Field):
 
 def make_annotation_gatherer(
     field_type=Field,
-    leave_default_values=True,
+    leave_default_values=False,
 ):
     """
     Create a new annotation gatherer that will work with `Field` instances
@@ -814,7 +811,7 @@ def make_annotation_gatherer(
 
 def make_field_gatherer(
     field_type=Field,
-    leave_default_values=True,
+    leave_default_values=False,
 ):
     def field_attribute_gatherer(cls_or_ns):
         if isinstance(cls_or_ns, (_MappingProxyType, dict)):
@@ -847,7 +844,7 @@ def make_field_gatherer(
 
 def make_unified_gatherer(
     field_type=Field,
-    leave_default_values=True,
+    leave_default_values=False,
 ):
     """
     Create a gatherer that will work via first slots, then
@@ -897,7 +894,7 @@ annotation_gatherer = make_annotation_gatherer()
 
 # The unified gatherer used for slot classes must remove default
 # values for slots to work correctly.
-unified_gatherer = make_unified_gatherer(leave_default_values=False)
+unified_gatherer = make_unified_gatherer()
 
 
 # Now the gatherers have been defined, add __repr__ and __eq__ to Field.
@@ -963,7 +960,7 @@ class AnnotationClass(metaclass=SlotMakerMeta):
     def __init_subclass__(
             cls,
             methods=default_methods,
-            gatherer=make_unified_gatherer(leave_default_values=True),
+            gatherer=unified_gatherer,
             **kwargs
     ):
         # Check class dict otherwise this will always be True as this base

{ducktools_classbuilder-0.7.0 → ducktools_classbuilder-0.7.2}/src/ducktools/classbuilder/__init__.pyi

@@ -178,37 +178,37 @@ def make_slot_gatherer(
 @typing.overload
 def make_annotation_gatherer(
     field_type: type[_FieldType],
-    leave_default_values: bool = True,
+    leave_default_values: bool = False,
 ) -> Callable[[type | _CopiableMappings], tuple[dict[str, _FieldType], dict[str, typing.Any]]]: ...
 
 @typing.overload
 def make_annotation_gatherer(
     field_type: _ReturnsField = Field,
-    leave_default_values: bool = True,
+    leave_default_values: bool = False,
 ) -> Callable[[type | _CopiableMappings], tuple[dict[str, Field], dict[str, typing.Any]]]: ...
 
 @typing.overload
 def make_field_gatherer(
     field_type: type[_FieldType],
-    leave_default_values: bool = True,
+    leave_default_values: bool = False,
 ) -> Callable[[type | _CopiableMappings], tuple[dict[str, _FieldType], dict[str, typing.Any]]]: ...
 
 @typing.overload
 def make_field_gatherer(
     field_type: _ReturnsField = Field,
-    leave_default_values: bool = True,
+    leave_default_values: bool = False,
 ) -> Callable[[type | _CopiableMappings], tuple[dict[str, Field], dict[str, typing.Any]]]: ...
 
 @typing.overload
 def make_unified_gatherer(
     field_type: type[_FieldType],
-    leave_default_values: bool = True,
+    leave_default_values: bool = False,
 ) -> Callable[[type | _CopiableMappings], tuple[dict[str, _FieldType], dict[str, typing.Any]]]: ...
 
 @typing.overload
 def make_unified_gatherer(
     field_type: _ReturnsField = Field,
-    leave_default_values: bool = True,
+    leave_default_values: bool = False,
 ) -> Callable[[type | _CopiableMappings], tuple[dict[str, Field], dict[str, typing.Any]]]: ...
 
 
@@ -249,7 +249,7 @@ class AnnotationClass(metaclass=SlotMakerMeta):
     def __init_subclass__(
         cls,
         methods: frozenset[MethodMaker] | set[MethodMaker] = default_methods,
-        gatherer: _gatherer_type = make_unified_gatherer(leave_default_values=True),
+        gatherer: _gatherer_type = unified_gatherer,
         **kwargs,
     ) -> None: ...
 

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

@@ -0,0 +1,2 @@
+__version__ = "0.7.2"
+__version_tuple__ = (0, 7, 2)