ducktools-classbuilder 0.7.1__tar.gz → 0.7.3__tar.gz

{ducktools_classbuilder-0.7.1 → ducktools_classbuilder-0.7.3}/.github/workflows/auto_test.yml

@@ -14,7 +14,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest]
-        python-version: ["3.13-dev", "3.12", "3.11", "3.10", "pypy-3.10", "3.9", "3.8"]
+        python-version: ["3.13", "3.12", "3.11", "3.10", "pypy-3.10", "3.9", "3.8"]
 
     steps:
     - uses: actions/checkout@v4
@@ -42,7 +42,7 @@ jobs:
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
-          python -m pip install -e .[testing]
+          python -m pip install -e .[testing,type_checking]
       - name: Check type stub files
         run: |
           python -m mypy.stubtest ducktools.classbuilder

{ducktools_classbuilder-0.7.1 → ducktools_classbuilder-0.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ducktools-classbuilder
-Version: 0.7.1
+Version: 0.7.3
 Summary: Toolkit for creating class boilerplate generators
 Author: David C Ellis
 License: MIT License
@@ -41,8 +41,9 @@ License-File: LICENSE.md
 Provides-Extra: testing
 Requires-Dist: pytest>=8.2; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
-Requires-Dist: mypy; extra == "testing"
 Requires-Dist: typing_extensions; extra == "testing"
+Provides-Extra: type-checking
+Requires-Dist: mypy; extra == "type-checking"
 Provides-Extra: performance-tests
 Requires-Dist: attrs; extra == "performance-tests"
 Requires-Dist: pydantic; extra == "performance-tests"

{ducktools_classbuilder-0.7.1 → ducktools_classbuilder-0.7.3}/docs/extension_examples.md

@@ -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

ducktools_classbuilder-0.7.3/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.1 → ducktools_classbuilder-0.7.3}/pyproject.toml

@@ -27,6 +27,12 @@ classifiers = [
 dynamic = ['version']
 license = {file = "LICENSE.md"}
 
+[project.optional-dependencies]
+testing = ["pytest>=8.2", "pytest-cov", "typing_extensions"]
+type_checking = ["mypy"]
+performance_tests = ["attrs", "pydantic"]
+docs = ["sphinx", "myst-parser", "sphinx_rtd_theme"]
+
 [tool.setuptools.packages.find]
 where = ["src"]
 
@@ -34,12 +40,6 @@ where = ["src"]
 version_file = "src/ducktools/classbuilder/_version.py"
 version_file_template = "__version__ = \"{version}\"\n__version_tuple__ = {version_tuple}\n"
 
-
-[project.optional-dependencies]
-testing = ["pytest>=8.2", "pytest-cov", "mypy", "typing_extensions"]
-performance_tests = ["attrs", "pydantic"]
-docs = ["sphinx", "myst-parser", "sphinx_rtd_theme"]
-
 [project.urls]
 "Homepage" = "https://github.com/davidcellis/ducktools-classbuilder"
 

{ducktools_classbuilder-0.7.1 → ducktools_classbuilder-0.7.3}/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'
@@ -741,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
@@ -807,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)):
@@ -840,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
@@ -890,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.
@@ -956,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.1 → ducktools_classbuilder-0.7.3}/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.3/src/ducktools/classbuilder/_version.py

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

{ducktools_classbuilder-0.7.1 → ducktools_classbuilder-0.7.3}/src/ducktools/classbuilder/annotations.py

@@ -37,6 +37,36 @@ del _cell_factory
 # End evil stuff from types.py
 
 
+class _Stringlike(str):
+    # There are typing operators that are not supported by strings
+    # This adds the 'or' operator '|'
+
+    def __or__(self, other):
+        if isinstance(other, str):
+            other_r = other
+        elif name := getattr(other, "__name__", None):
+            other_r = name
+        else:
+            other_r = str(other)
+
+        return type(self)(f"{self} | {other_r}")
+
+    def __ror__(self, other):
+        if isinstance(other, str):
+            other_r = other
+        elif name := getattr(other, "__name__", None):
+            other_r = name
+        else:
+            other_r = str(other)
+
+        return type(self)(f"{other_r} | {self}")
+
+    def __repr__(self):
+        base = super().__repr__()
+        clsname = type(self).__name__
+        return f"{clsname}({base})"
+
+
 class _StringGlobs(dict):
     """
     Based on the fake globals dictionary used for annotations
@@ -47,7 +77,7 @@ class _StringGlobs(dict):
     is not found.
     """
     def __missing__(self, key):
-        return key
+        return _Stringlike(key)
 
     def __repr__(self):
         cls_name = self.__class__.__name__
@@ -165,7 +195,14 @@ def call_annotate_func(annotate):
         closure = None
 
     new_annotate = _FunctionType(annotate.__code__, globs, closure=closure)
-    return new_annotate(1)
+
+    # Convert _Stringlike back to str
+    annos = {
+        k: str(v) if isinstance(v, _Stringlike) else v
+        for k, v in new_annotate(1).items()
+    }
+
+    return annos
 
 
 def get_ns_annotations(ns, eval_str=True):

{ducktools_classbuilder-0.7.1 → ducktools_classbuilder-0.7.3}/src/ducktools_classbuilder.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ducktools-classbuilder
-Version: 0.7.1
+Version: 0.7.3
 Summary: Toolkit for creating class boilerplate generators
 Author: David C Ellis
 License: MIT License
@@ -41,8 +41,9 @@ License-File: LICENSE.md
 Provides-Extra: testing
 Requires-Dist: pytest>=8.2; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
-Requires-Dist: mypy; extra == "testing"
 Requires-Dist: typing_extensions; extra == "testing"
+Provides-Extra: type-checking
+Requires-Dist: mypy; extra == "type-checking"
 Provides-Extra: performance-tests
 Requires-Dist: attrs; extra == "performance-tests"
 Requires-Dist: pydantic; extra == "performance-tests"

{ducktools_classbuilder-0.7.1 → ducktools_classbuilder-0.7.3}/src/ducktools_classbuilder.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ docs/make.bat
 docs/tutorial.md
 docs/perf/performance_tests.md
 docs/prefab/index.md
+docs_code/docs_ex10_frozen_attributes.py
 docs_code/docs_ex1_basic.py
 docs_code/docs_ex2_register.py
 docs_code/docs_ex3_iterable.py

{ducktools_classbuilder-0.7.1 → ducktools_classbuilder-0.7.3}/src/ducktools_classbuilder.egg-info/requires.txt

@@ -11,5 +11,7 @@ pydantic
 [testing]
 pytest>=8.2
 pytest-cov
-mypy
 typing_extensions
+
+[type_checking]
+mypy

{ducktools_classbuilder-0.7.1 → ducktools_classbuilder-0.7.3}/tests/annotations/test_annotated.py

@@ -60,9 +60,10 @@ def test_annotation_gatherer():
     for key in "defgh":
         assert key not in annos
 
-    # Instance variables not removed from class
-    # Field replaced with default value on class
-    assert modifications["c"] == "c"
+    # Instance variables to be removed from class
+    assert modifications["a"] is NOTHING
+    assert modifications["b"] is NOTHING
+    assert modifications["c"] is NOTHING
 
 
 def test_make_annotation_gatherer():
@@ -71,7 +72,7 @@ def test_make_annotation_gatherer():
 
     gatherer = make_annotation_gatherer(
         field_type=NewField,
-        leave_default_values=False,
+        leave_default_values=True,
     )
 
     class ExampleAnnotated:
@@ -91,10 +92,11 @@ def test_make_annotation_gatherer():
 
     assert annos["blank_field"] == NewField(type=str)
 
-    # ABC should be present in annos but removed from the class
+    # ABC should be present in annos and in the class
     for key in "abc":
         assert annos[key] == NewField(default=key, type=annotations[key])
-        assert modifications[key] is NOTHING
+
+    assert modifications["c"] == "c"
 
     # Opposite for classvar
     for key in "defgh":
@@ -114,7 +116,10 @@ def test_annotationclass():
         g: Annotated[Annotated[ClassVar[str], ""], ""] = "g"
         h: Annotated[CV[str], ''] = "h"
 
-    for key in "abcdefgh":
+    for key in "abc":
+        assert key not in ExampleAnnotated.__dict__
+
+    for key in "defgh":
         assert key in ExampleAnnotated.__dict__
 
     ex = ExampleAnnotated()

{ducktools_classbuilder-0.7.1 → ducktools_classbuilder-0.7.3}/tests/test_core.py

@@ -9,10 +9,13 @@ from ducktools.classbuilder import (
     builder,
     default_methods,
     eq_maker,
+    frozen_delattr_maker,
+    frozen_setattr_maker,
     get_fields,
     get_flags,
     get_methods,
     init_maker,
+    make_unified_gatherer,
     slot_gatherer,
     slotclass,
 
@@ -165,6 +168,30 @@ def test_frozen_field():
             delattr(f, k)
 
 
+def test_frozen_unslotted():
+    # Test a frozen class with defaults left in place
+
+    methods = default_methods | {frozen_setattr_maker, frozen_delattr_maker}
+    gatherer = make_unified_gatherer(Field, leave_default_values=True)
+
+    def b(cls):
+        return builder(cls, methods=methods, gatherer=gatherer,
+                       flags={"frozen": True, "slotted": False})
+
+    @b
+    class Ex:
+        a: int = 41
+        b: str = "Hello"
+
+    ex = Ex()
+
+    with pytest.raises(TypeError):
+        ex.a = 42
+
+    with pytest.raises(TypeError):
+        ex.b = "goodbye"
+
+
 def test_slot_gatherer_success():
 
     fields = {

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

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