ducktools-classbuilder 0.2.0__tar.gz → 0.3.0__tar.gz

{ducktools_classbuilder-0.2.0/src/ducktools_classbuilder.egg-info → ducktools_classbuilder-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ducktools-classbuilder
-Version: 0.2.0
+Version: 0.3.0
 Summary: Toolkit for creating class boilerplate generators
 Author: David C Ellis
 License: MIT License

{ducktools_classbuilder-0.2.0 → ducktools_classbuilder-0.3.0}/src/ducktools/classbuilder/__init__.py

@@ -19,34 +19,12 @@
 # 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.0"
+__version__ = "v0.3.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)
-
-
 def get_fields(cls, *, local=False):
     """
     Utility function to gather the fields dictionary
@@ -71,7 +49,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 +85,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,7 +102,7 @@ class MethodMaker:
         return method.__get__(instance, cls)
 
 
-def init_maker(cls, *, null=NOTHING):
+def init_maker(cls, *, null=NOTHING, extra_code=None):
     fields = get_fields(cls)
     flags = get_flags(cls)
 
@@ -150,8 +130,17 @@ def init_maker(cls, *, null=NOTHING):
         assignments.append(assignment)
 
     args = ", ".join(arglist)
-    assigns = "\n    ".join(assignments)
-    code = f"def __init__(self, {args}):\n" f"    {assigns}\n"
+    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
 
 
@@ -300,7 +289,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)
 
@@ -407,6 +396,14 @@ def slotclass(cls=None, /, *, methods=default_methods, syntax_check=True):
     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 fieldclass(cls):
     """
     This is a special decorator for making Field subclasses using __slots__.
@@ -417,18 +414,7 @@ def fieldclass(cls):
     :return: Modified subclass
     """
 
-    # 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_nothing = _NothingType()
-    field_init_desc = MethodMaker(
-        "__init__",
-        field_init_func,
-    )
+    field_init_desc = MethodMaker("__init__", _field_init_func)
     field_methods = frozenset({field_init_desc, repr_desc, eq_desc})
 
     cls = builder(

{ducktools_classbuilder-0.2.0 → ducktools_classbuilder-0.3.0}/src/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:
     ...
@@ -32,6 +30,7 @@ def init_maker(
     cls: type,
     *,
     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]]: ...

{ducktools_classbuilder-0.2.0 → ducktools_classbuilder-0.3.0}/src/ducktools/classbuilder/prefab.py

@@ -398,7 +398,7 @@ def get_asdict_maker():
         vals = ", ".join(
             f"'{name}': self.{name}"
             for name, attrib in fields.items()
-            if attrib.in_dict and not attrib.exclude_field
+            if attrib.serialize and not attrib.exclude_field
         )
         out_dict = f"{{{vals}}}"
         code = f"def as_dict(self): return {out_dict}"
@@ -428,7 +428,7 @@ class Attribute(Field):
         compare=True,
         iter=True,
         kw_only=False,
-        in_dict=True,
+        serialize=True,
         exclude_field=False,
     )
 
@@ -450,7 +450,7 @@ def attribute(
     compare=True,
     iter=True,
     kw_only=False,
-    in_dict=True,
+    serialize=True,
     exclude_field=False,
     doc=None,
     type=NOTHING,
@@ -466,7 +466,7 @@ def attribute(
     :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 in_dict: Include this attribute in methods that serialise to dict
+    :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
@@ -484,7 +484,7 @@ def attribute(
         compare=compare,
         iter=iter,
         kw_only=kw_only,
-        in_dict=in_dict,
+        serialize=serialize,
         exclude_field=exclude_field,
         doc=doc,
         type=type,
@@ -906,7 +906,7 @@ def is_prefab_instance(o):
 
 def as_dict(o):
     """
-    Get the valid fields from a prefab respecting the in_dict
+    Get the valid fields from a prefab respecting the serialize
     values of attributes
 
     :param o: instance of a prefab class
@@ -927,5 +927,5 @@ def as_dict(o):
     return {
         name: getattr(o, name)
         for name, attrib in flds.items()
-        if attrib.in_dict and not attrib.exclude_field
+        if attrib.serialize and not attrib.exclude_field
     }

{ducktools_classbuilder-0.2.0 → ducktools_classbuilder-0.3.0}/src/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
@@ -63,7 +63,7 @@ class Attribute(Field):
     compare: bool
     iter: bool
     kw_only: bool
-    in_dict: bool
+    serialize: bool
     exclude_field: bool
 
     def __init__(
@@ -78,7 +78,7 @@ class Attribute(Field):
         compare: bool = True,
         iter: bool = True,
         kw_only: bool = False,
-        in_dict: bool = True,
+        serialize: bool = True,
         exclude_field: bool = False,
     ) -> None: ...
 
@@ -97,7 +97,7 @@ def attribute(
     compare: bool = True,
     iter: bool = True,
     kw_only: bool = False,
-    in_dict: bool = True,
+    serialize: bool = True,
     exclude_field: bool = False,
 ) -> Attribute: ...
 

{ducktools_classbuilder-0.2.0 → ducktools_classbuilder-0.3.0/src/ducktools_classbuilder.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ducktools-classbuilder
-Version: 0.2.0
+Version: 0.3.0
 Summary: Toolkit for creating class boilerplate generators
 Author: David C Ellis
 License: MIT License

{ducktools_classbuilder-0.2.0 → ducktools_classbuilder-0.3.0}/src/ducktools_classbuilder.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ src/ducktools_classbuilder.egg-info/SOURCES.txt
 src/ducktools_classbuilder.egg-info/dependency_links.txt
 src/ducktools_classbuilder.egg-info/requires.txt
 src/ducktools_classbuilder.egg-info/top_level.txt
+tests/test_core.py
 tests/prefab/dynamic/test_compare_attrib.py
 tests/prefab/dynamic/test_construction.py
 tests/prefab/dynamic/test_internals.py

{ducktools_classbuilder-0.2.0 → ducktools_classbuilder-0.3.0}/tests/prefab/shared/test_funcs.py

@@ -45,18 +45,18 @@ def test_as_dict_excludes():
     @prefab
     class ExcludesUncached:
         name: str
-        password: str = attribute(in_dict=False)
+        password: str = attribute(serialize=False)
 
     @prefab(dict_method=True)
     class ExcludesCached:
         name: str
-        password: str = attribute(in_dict=False)
+        password: str = attribute(serialize=False)
 
     @prefab(dict_method=True)
     class ExcludesSlots:
         __slots__ = SlotFields(
             name=attribute(type=str),
-            password=attribute(in_dict=False, type=str)
+            password=attribute(serialize=False, type=str)
         )
 
     @prefab(dict_method=True)

ducktools_classbuilder-0.3.0/tests/test_core.py

@@ -0,0 +1,319 @@
+# Tests for the core 'builder'
+import pytest
+
+from ducktools.classbuilder import (
+    INTERNALS_DICT,
+    NOTHING,
+    get_fields,
+    get_flags,
+    MethodMaker,
+    init_desc,
+    builder,
+    Field,
+    SlotFields,
+    slot_gatherer,
+    slotclass,
+    fieldclass,
+)
+
+
+def test_get_fields_flags():
+    local_fields = {"Example": Field()}
+    resolved_fields = {"ParentField": Field(), "Example": Field()}
+    flags = {"slotted": False}
+
+    internals_dict = {
+        "fields": resolved_fields,
+        "local_fields": local_fields,
+        "flags": flags,
+    }
+
+    class ExampleFields:
+        ...
+
+    setattr(ExampleFields, INTERNALS_DICT, internals_dict)
+
+    assert get_fields(ExampleFields) == resolved_fields
+    assert get_fields(ExampleFields, local=True) == local_fields
+    assert get_flags(ExampleFields) == flags
+
+
+def test_method_maker():
+    def generator(cls):
+        code = "def demo(self): return self.x"
+        globs = {}
+        return code, globs
+
+    method_desc = MethodMaker("demo", generator)
+
+    assert repr(method_desc) == "<MethodMaker for 'demo' method>"
+
+    class ValueX:
+        demo = method_desc
+
+        def __init__(self):
+            self.x = "Example Value"
+
+    ex = ValueX()
+
+    assert ValueX.__dict__["demo"] == method_desc
+
+    assert ex.x == "Example Value"
+    assert ex.demo() == "Example Value"
+
+    # Should no longer be equal as demo was called
+    assert ValueX.__dict__["demo"] != method_desc
+
+
+def test_construct_field():
+    f = Field()
+    assert f.default is NOTHING
+    assert f.default_factory is NOTHING
+    assert f.type is NOTHING
+    assert f.doc is None
+
+    with pytest.raises(AttributeError):
+        Field(default=None, default_factory=list)
+
+
+def test_eq_field():
+    f1 = Field(default=True)
+    f2 = Field(default=False)
+    f3 = Field(default_factory=list)
+    f4 = Field(default=True, type=bool)
+    f5 = Field(default=True, doc="True or False")
+
+    assert f1 != f2
+    assert f1 != f3
+    assert f1 != f4
+    assert f1 != f5
+
+    f1r = Field(default=True)
+    assert f1 == f1r
+
+
+def test_from_field():
+    f1 = Field(default=True)
+    f2 = Field(default=False)
+    f3 = Field(default_factory=list)
+    f4 = Field(default=True, type=bool)
+    f5 = Field(default=True, doc="True or False")
+
+    for fld in [f1, f2, f3, f4, f5]:
+        assert fld == Field.from_field(fld)
+
+
+def test_repr_field():
+    f1 = Field(default=True)
+    f2 = Field(default=False)
+    f3 = Field(default_factory=list)
+    f4 = Field(default=True, type=bool)
+    f5 = Field(default=True, doc="True or False")
+
+    nothing_repr = repr(NOTHING)
+
+    f1_repr = f"Field(default=True, default_factory={nothing_repr}, type={nothing_repr}, doc=None)"
+    f2_repr = f"Field(default=False, default_factory={nothing_repr}, type={nothing_repr}, doc=None)"
+    f3_repr = f"Field(default={nothing_repr}, default_factory=<class 'list'>, type={nothing_repr}, doc=None)"
+    f4_repr = f"Field(default=True, default_factory={nothing_repr}, type=<class 'bool'>, doc=None)"
+    f5_repr = f"Field(default=True, default_factory={nothing_repr}, type={nothing_repr}, doc='True or False')"
+
+    assert repr(f1) == f1_repr
+    assert repr(f2) == f2_repr
+    assert repr(f3) == f3_repr
+    assert repr(f4) == f4_repr
+    assert repr(f5) == f5_repr
+
+
+def test_slot_gatherer_success():
+
+    fields = {
+        "a": Field(default=1),
+        "b": Field(default=2),
+        "c": Field(default_factory=list, doc="a list"),
+        "d": Field(type=str)
+    }
+
+    class SlotsExample:
+        __slots__ = SlotFields(
+            a=1,
+            b=Field(default=2),
+            c=Field(default_factory=list, doc="a list"),
+            d=Field(type=str),
+        )
+
+    slots = slot_gatherer(SlotsExample)
+
+    assert slots == fields
+    assert SlotsExample.__slots__ == {"a": None, "b": None, "c": "a list", "d": None}
+    assert SlotsExample.__annotations__ == {"d": str}
+
+
+def test_slot_gatherer_failure():
+    class NoSlots:
+        ...
+
+    with pytest.raises(TypeError):
+        slot_gatherer(NoSlots)
+
+    class WrongSlots:
+        __slots__ = ["a", "b", "c"]
+
+    with pytest.raises(TypeError):
+        slot_gatherer(WrongSlots)
+
+    class DictSlots:
+        __slots__ = {"a": "documentation"}
+
+    with pytest.raises(TypeError):
+        slot_gatherer(DictSlots)
+
+
+def test_slotclass_empty():
+    @slotclass
+    class SlotClass:
+        __slots__ = SlotFields()
+
+    ex = SlotClass()
+    ex2 = SlotClass()
+
+    assert repr(ex) == "test_slotclass_empty.<locals>.SlotClass()"
+    assert ex == ex2
+
+
+def test_slotclass_methods():
+
+    class SlotClass:
+        __slots__ = SlotFields()
+
+    assert "__init__" not in SlotClass.__dict__
+    assert "__repr__" not in SlotClass.__dict__
+    assert "__eq__" not in SlotClass.__dict__
+
+    SlotClass = slotclass(SlotClass)
+
+    assert "__init__" in SlotClass.__dict__
+    assert "__repr__" in SlotClass.__dict__
+    assert "__eq__" in SlotClass.__dict__
+
+
+def test_slotclass_attributes():
+    @slotclass
+    class SlotClass:
+        __slots__ = SlotFields(
+            a=1,
+            b=Field(default=2, type=int),
+            c=Field(default_factory=list, doc="a list"),
+        )
+
+    prefix = "test_slotclass_attributes.<locals>."
+
+    ex = SlotClass()
+    ex2 = SlotClass()
+    ex3 = SlotClass(c=[1, 2, 3])
+    ex4 = SlotClass(4, 5, [1, 2, 3])
+
+    assert ex.a == 1
+    assert ex.b == 2
+    assert ex.c == []
+
+    assert ex3.c == [1, 2, 3]
+
+    assert ex4.a == 4
+    assert ex4.b == 5
+    assert ex4.c == [1, 2, 3]
+
+    assert ex == ex2
+    assert ex != ex3
+
+    assert repr(ex) == f"{prefix}SlotClass(a=1, b=2, c=[])"
+    assert repr(ex3) == f"{prefix}SlotClass(a=1, b=2, c=[1, 2, 3])"
+
+
+def test_slotclass_nodefault():
+    @slotclass
+    class SlotClass:
+        __slots__ = SlotFields(
+            a=Field(),
+            b=2,
+            c=Field(default_factory=list, doc="a list"),
+        )
+
+    ex = SlotClass(1)
+    ex2 = SlotClass(a=2, b=4, c=[8, 16, 32])
+
+    assert ex.a == 1
+    assert ex.b == 2
+    assert ex.c == []
+
+    assert ex2.a == 2
+    assert ex2.b == 4
+    assert ex2.c == [8, 16, 32]
+
+
+def test_slotclass_ordering():
+    with pytest.raises(SyntaxError):
+        # Non-default argument after default
+        @slotclass
+        class OrderingError:
+            __slots__ = SlotFields(
+                x=1,
+                y=Field(),
+            )
+
+
+def test_slotclass_norepr_noeq():
+    @slotclass(methods={init_desc})
+    class SlotClass:
+        __slots__ = SlotFields(
+            a=Field(),
+            b=2,
+            c=Field(default_factory=list, doc="a list"),
+        )
+
+    assert "__repr__" not in SlotClass.__dict__
+    assert "__eq__" not in SlotClass.__dict__
+
+
+def test_fieldclass():
+    @fieldclass
+    class NewField(Field):
+        __slots__ = SlotFields(serialize=True)
+
+    f = NewField()
+
+    assert f.default is NOTHING
+    assert f.default_factory is NOTHING
+    assert f.type is NOTHING
+    assert f.doc is None
+    assert f.serialize is True
+
+    f2 = NewField(default=1, serialize=False)
+
+    assert f2.default == 1
+    assert f2.serialize is False
+
+    with pytest.raises(TypeError):
+        # All arguments are keyword only in fieldclasses
+        NewField(42)
+
+
+def test_builder_noclass():
+    mini_slotclass = builder(gatherer=slot_gatherer, methods={init_desc})
+
+    @mini_slotclass
+    class SlotClass:
+        __slots__ = SlotFields(
+            a=Field(),
+            b=2,
+            c=Field(default_factory=list, doc="a list"),
+        )
+
+    assert "__init__" in SlotClass.__dict__
+    assert "__repr__" not in SlotClass.__dict__
+    assert "__eq__" not in SlotClass.__dict__
+
+    x = SlotClass(12)
+    assert x.a == 12
+    assert x.b == 2
+    assert x.c == []