ducktools-classbuilder 0.8.3__tar.gz → 0.9.0__tar.gz

{ducktools_classbuilder-0.8.3 → ducktools_classbuilder-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ducktools-classbuilder
-Version: 0.8.3
+Version: 0.9.0
 Summary: Toolkit for creating class boilerplate generators
 Author: David C Ellis
 Project-URL: Homepage, https://github.com/davidcellis/ducktools-classbuilder

{ducktools_classbuilder-0.8.3 → ducktools_classbuilder-0.9.0}/src/ducktools/classbuilder/__init__.py

@@ -33,7 +33,7 @@
 import os
 
 from .annotations import get_ns_annotations, is_classvar
-from ._version import __version__, __version_tuple__
+from ._version import __version__, __version_tuple__  # noqa: F401
 
 # Change this name if you make heavy modifications
 INTERNALS_DICT = "__classbuilder_internals__"
@@ -47,7 +47,7 @@ _UNDER_TESTING = os.environ.get("PYTEST_VERSION") is not None
 # Obtain types the same way types.py does in pypy
 # See: https://github.com/pypy/pypy/blob/19d9fa6be11165116dd0839b9144d969ab426ae7/lib-python/3/types.py#L61-L73
 class _C: __slots__ = 's'  # noqa
-_MemberDescriptorType = type(_C.s)  # noqa
+_MemberDescriptorType = type(_C.s)  # type: ignore
 _MappingProxyType = type(type.__dict__)
 del _C
 
@@ -280,7 +280,7 @@ def get_init_generator(null=NOTHING, extra_code=None):
 
         assigns = "\n    ".join(assignments) if assignments else "pass\n"
         code = (
-            f"def {funcname}(self, {args}):\n" 
+            f"def {funcname}(self, {args}):\n"
             f"    {assigns}\n"
         )
         # Handle additional function calls
@@ -663,10 +663,10 @@ class Field(metaclass=SlotMakerMeta):
     def from_field(cls, fld, /, **kwargs):
         """
         Create an instance of field or subclass from another field.
-        
-        This is intended to be used to convert a base 
+
+        This is intended to be used to convert a base
         Field into a subclass.
-        
+
         :param fld: field class to convert
         :param kwargs: Additional keyword arguments for subclasses
         :return: new field subclass instance
@@ -762,7 +762,9 @@ def make_annotation_gatherer(
         else:
             cls_dict = cls_or_ns.__dict__
 
-        cls_fields: dict[str, field_type] = {}
+        # This should really be dict[str, field_type] but static analysis
+        # doesn't understand this.
+        cls_fields: dict[str, Field] = {}
         modifications = {}
 
         cls_annotations = get_ns_annotations(cls_dict)
@@ -959,24 +961,6 @@ def slotclass(cls=None, /, *, methods=default_methods, syntax_check=True):
     return cls
 
 
-class AnnotationClass(metaclass=SlotMakerMeta):
-    __slots__ = {}
-
-    def __init_subclass__(
-            cls,
-            methods=default_methods,
-            gatherer=unified_gatherer,
-            **kwargs
-    ):
-        # Check class dict otherwise this will always be True as this base
-        # class uses slots.
-        slots = "__slots__" in cls.__dict__
-
-        builder(cls, gatherer=gatherer, methods=methods, flags={"slotted": slots})
-        check_argument_order(cls)
-        super().__init_subclass__(**kwargs)
-
-
 @slotclass
 class GatheredFields:
     """

{ducktools_classbuilder-0.8.3 → ducktools_classbuilder-0.9.0}/src/ducktools/classbuilder/__init__.pyi

@@ -5,7 +5,6 @@ import inspect
 
 from collections.abc import Callable
 from types import MappingProxyType
-from typing_extensions import dataclass_transform
 
 _py_type = type | str  # Alias for type hint values
 _CopiableMappings = dict[str, typing.Any] | MappingProxyType[str, typing.Any]
@@ -244,18 +243,6 @@ def slotclass(
 
 _gatherer_type = Callable[[type | _CopiableMappings], tuple[dict[str, Field], dict[str, typing.Any]]]
 
-
-@dataclass_transform(field_specifiers=(Field,))
-class AnnotationClass(metaclass=SlotMakerMeta):
-    __slots__: dict
-
-    def __init_subclass__(
-        cls,
-        methods: frozenset[MethodMaker] | set[MethodMaker] = default_methods,
-        gatherer: _gatherer_type = unified_gatherer,
-        **kwargs,
-    ) -> None: ...
-
 class GatheredFields:
     __slots__: dict[str, None]
 

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

@@ -0,0 +1,2 @@
+__version__ = "0.9.0"
+__version_tuple__ = (0, 9, 0)

{ducktools_classbuilder-0.8.3 → ducktools_classbuilder-0.9.0}/src/ducktools/classbuilder/annotations.py

@@ -25,7 +25,7 @@ import sys
 class _LazyAnnotationLib:
     def __getattr__(self, item):
         global _lazyannotationlib
-        import annotationlib
+        import annotationlib  # type: ignore
         _lazyannotationlib = annotationlib
         return getattr(annotationlib, item)
 

{ducktools_classbuilder-0.8.3 → ducktools_classbuilder-0.9.0}/src/ducktools/classbuilder/prefab.py

@@ -36,7 +36,7 @@ from . import (
 
 # These aren't used but are re-exported for ease of use
 # noinspection PyUnresolvedReferences
-from . import SlotFields, KW_ONLY
+from . import SlotFields, KW_ONLY  # noqa: F401
 
 PREFAB_FIELDS = "PREFAB_FIELDS"
 PREFAB_INIT_FUNC = "__prefab_init__"
@@ -294,7 +294,7 @@ class Attribute(Field):
     """
     iter: bool = True
     serialize: bool = True
-    metadata: dict = Field(default=FIELD_NOTHING, default_factory=dict)
+    metadata: dict = Field(default=FIELD_NOTHING, default_factory=dict)  # type: ignore
 
 
 # noinspection PyShadowingBuiltins
@@ -551,7 +551,7 @@ def _make_prefab(
 
 class Prefab(metaclass=SlotMakerMeta):
     _meta_gatherer = prefab_gatherer
-    __slots__ = {}
+    __slots__ = {}  # type: ignore
 
     # noinspection PyShadowingBuiltins
     def __init_subclass__(

{ducktools_classbuilder-0.8.3 → ducktools_classbuilder-0.9.0}/src/ducktools/classbuilder/prefab.pyi

@@ -4,7 +4,8 @@ from typing_extensions import dataclass_transform
 
 import inspect
 
-from collections.abc import Callable
+# Suppress weird pylance error
+from collections.abc import Callable  # type: ignore
 
 from . import (
     NOTHING,
@@ -58,36 +59,73 @@ class Attribute(Field):
         default: typing.Any | _NothingType = NOTHING,
         default_factory: typing.Any | _NothingType = NOTHING,
         type: type | _NothingType = NOTHING,
-        doc: str | None = None,
-        init: bool = True,
-        repr: bool = True,
-        compare: bool = True,
-        iter: bool = True,
-        kw_only: bool = False,
-        serialize: bool = True,
-        metadata: dict | None = None,
+        doc: str | None = ...,
+        init: bool = ...,
+        repr: bool = ...,
+        compare: bool = ...,
+        iter: bool = ...,
+        kw_only: bool = ...,
+        serialize: bool = ...,
+        metadata: dict | None = ...,
     ) -> None: ...
 
     def __repr__(self) -> str: ...
     def __eq__(self, other: Attribute | object) -> bool: ...
     def validate_field(self) -> None: ...
 
+@typing.overload
 def attribute(
     *,
-    default: typing.Any | _NothingType = NOTHING,
-    default_factory: typing.Any | _NothingType = NOTHING,
-    init: bool = True,
-    repr: bool = True,
-    compare: bool = True,
-    iter: bool = True,
-    kw_only: bool = False,
-    serialize: bool = True,
-    exclude_field: bool = False,
-    private: bool = False,
-    doc: str | None = None,
-    metadata: dict | None = None,
-    type: type | _NothingType = NOTHING,
-) -> Attribute: ...
+    default: _T,
+    default_factory: _NothingType = NOTHING,
+    init: bool = ...,
+    repr: bool = ...,
+    compare: bool = ...,
+    iter: bool = ...,
+    kw_only: bool = ...,
+    serialize: bool = ...,
+    exclude_field: bool = ...,
+    private: bool = ...,
+    doc: str | None = ...,
+    metadata: dict | None = ...,
+    type: type | _NothingType = ...,
+) -> _T: ...
+
+@typing.overload
+def attribute(
+    *,
+    default: _NothingType = NOTHING,
+    default_factory: Callable[[], _T],
+    init: bool = ...,
+    repr: bool = ...,
+    compare: bool = ...,
+    iter: bool = ...,
+    kw_only: bool = ...,
+    serialize: bool = ...,
+    exclude_field: bool = ...,
+    private: bool = ...,
+    doc: str | None = ...,
+    metadata: dict | None = ...,
+    type: type | _NothingType = ...,
+) -> _T: ...
+
+@typing.overload
+def attribute(
+    *,
+    default: _NothingType = NOTHING,
+    default_factory: _NothingType = NOTHING,
+    init: bool = ...,
+    repr: bool = ...,
+    compare: bool = ...,
+    iter: bool = ...,
+    kw_only: bool = ...,
+    serialize: bool = ...,
+    exclude_field: bool = ...,
+    private: bool = ...,
+    doc: str | None = ...,
+    metadata: dict | None = ...,
+    type: type | _NothingType = ...,
+) -> typing.Any: ...
 
 def prefab_gatherer(cls_or_ns: type | MappingProxyType) -> tuple[dict[str, Attribute], dict[str, typing.Any]]: ...
 
@@ -111,7 +149,8 @@ _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]]]
+    _meta_gatherer: Callable[[type | _CopiableMappings], tuple[dict[str, Field], dict[str, typing.Any]]] = ...
+    __slots__: dict[str, typing.Any] = ...
     def __init_subclass__(
         cls,
         init: bool = True,
@@ -125,23 +164,56 @@ class Prefab(metaclass=SlotMakerMeta):
         recursive_repr: bool = False,
     ) -> None: ...
 
-
-# For some reason PyCharm can't see 'attribute'?!?
-# noinspection PyUnresolvedReferences
+# As far as I can tell these are the correct types
+# But mypy.stubtest crashes trying to analyse them
+# Due to the combination of overload and dataclass_transform
+# @typing.overload
+# def prefab(
+#     cls: None = None,
+#     *,
+#     init: bool = ...,
+#     repr: bool = ...,
+#     eq: bool = ...,
+#     iter: bool = ...,
+#     match_args: bool = ...,
+#     kw_only: bool = ...,
+#     frozen: bool = ...,
+#     dict_method: bool = ...,
+#     recursive_repr: bool = ...,
+# ) -> Callable[[type[_T]], type[_T]]: ...
+
+# @dataclass_transform(field_specifiers=(Attribute, attribute))
+# @typing.overload
+# def prefab(
+#     cls: type[_T],
+#     *,
+#     init: bool = ...,
+#     repr: bool = ...,
+#     eq: bool = ...,
+#     iter: bool = ...,
+#     match_args: bool = ...,
+#     kw_only: bool = ...,
+#     frozen: bool = ...,
+#     dict_method: bool = ...,
+#     recursive_repr: bool = ...,
+# ) -> type[_T]: ...
+
+# As mypy crashes, and the only difference is the return type
+# just return `Any` for now to avoid the overload.
 @dataclass_transform(field_specifiers=(Attribute, attribute))
 def prefab(
-    cls: type[_T] | None = None,
+    cls: type[_T] | None = ...,
     *,
-    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,
-) -> type[_T] | Callable[[type[_T]], type[_T]]: ...
+    init: bool = ...,
+    repr: bool = ...,
+    eq: bool = ...,
+    iter: bool = ...,
+    match_args: bool = ...,
+    kw_only: bool = ...,
+    frozen: bool = ...,
+    dict_method: bool = ...,
+    recursive_repr: bool = ...,
+) -> typing.Any: ...
 
 def build_prefab(
     class_name: str,

{ducktools_classbuilder-0.8.3 → ducktools_classbuilder-0.9.0}/src/ducktools_classbuilder.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ducktools-classbuilder
-Version: 0.8.3
+Version: 0.9.0
 Summary: Toolkit for creating class boilerplate generators
 Author: David C Ellis
 Project-URL: Homepage, https://github.com/davidcellis/ducktools-classbuilder

{ducktools_classbuilder-0.8.3 → ducktools_classbuilder-0.9.0}/tests/annotations/test_annotated.py

@@ -4,14 +4,13 @@ does not interfere when wrapping ClassVar
 """
 
 import sys
-import pytest
 
 from typing import ClassVar
 from typing_extensions import Annotated
 
 from ducktools.classbuilder import (
     Field, SlotFields, NOTHING,
-    AnnotationClass, annotation_gatherer, make_annotation_gatherer
+    annotation_gatherer, make_annotation_gatherer
 )
 
 from ducktools.classbuilder.annotations import (
@@ -102,43 +101,3 @@ def test_make_annotation_gatherer():
     for key in "defgh":
         assert key not in annos
         assert key not in modifications
-
-
-def test_annotationclass():
-    class ExampleAnnotated(AnnotationClass, slots=False):
-        a: str = "a"
-        b: "list[str]" = "b"
-        c: Annotated[str, ""] = Field(default="c")
-
-        d: ClassVar[str] = "d"
-        e: Annotated[ClassVar[str], ""] = "e"
-        f: "Annotated[ClassVar[str], '']" = "f"
-        g: Annotated[Annotated[ClassVar[str], ""], ""] = "g"
-        h: Annotated[CV[str], ''] = "h"
-
-    for key in "abc":
-        assert key not in ExampleAnnotated.__dict__
-
-    for key in "defgh":
-        assert key in ExampleAnnotated.__dict__
-
-    ex = ExampleAnnotated()
-    for char in "abcdefgh":
-        assert getattr(ex, char) == char
-
-    ex2 = ExampleAnnotated()
-    ex3 = ExampleAnnotated("i", "j", "k")
-
-    assert ex == ex2
-    assert ex != ex3
-
-    prefix = "test_annotationclass.<locals>."
-    assert repr(ex) == f"{prefix}ExampleAnnotated(a='a', b='b', c='c')"
-
-
-def test_annotated_syntax_error():
-    with pytest.raises(SyntaxError):
-        class ExampleAnnotated(AnnotationClass):
-            a: str = "a"  # noqa: the error being highlighted is the error we are testing.
-            b: "list[str]"
-            c: Annotated[str, ""] = Field(default="c")

{ducktools_classbuilder-0.8.3 → ducktools_classbuilder-0.9.0}/tests/prefab/dynamic/test_subclass_implementation.py

@@ -2,7 +2,7 @@ import inspect
 
 import pytest
 
-from ducktools.classbuilder.prefab import Prefab, Attribute, SlotFields
+from ducktools.classbuilder.prefab import Prefab, Attribute, SlotFields, get_attributes
 
 
 class TestConstructionForms:
@@ -178,3 +178,49 @@ class TestClassArguments:
         assert params['a'].kind == inspect.Parameter.KEYWORD_ONLY
         assert params['b'].kind == inspect.Parameter.KEYWORD_ONLY
         assert params['b'].default == 1
+
+
+def test_slots_weakref():
+    import weakref
+
+    class WeakrefClass(Prefab):
+        a: int = 1
+        b: int = 2
+        __weakref__: dict
+
+    flds = get_attributes(WeakrefClass)
+    assert 'a' in flds
+    assert 'b' in flds
+    assert '__weakref__' not in flds
+
+    slots = WeakrefClass.__slots__
+    assert 'a' in slots
+    assert 'b' in slots
+    assert '__weakref__' in slots
+
+    # Test weakrefs can be created
+    inst = WeakrefClass()
+    ref = weakref.ref(inst)
+    assert ref == inst.__weakref__
+
+
+def test_has_dict():
+    class DictClass(Prefab):
+        a: int = 1
+        b: int = 2
+        __dict__: dict
+
+    flds = get_attributes(DictClass)
+    assert 'a' in flds
+    assert 'b' in flds
+    assert '__dict__' not in flds
+
+    slots = DictClass.__slots__
+    assert 'a' in slots
+    assert 'b' in slots
+    assert '__dict__' in slots
+
+    # Test if __dict__ is included new values can be added
+    inst = DictClass()
+    inst.c = 42
+    assert inst.__dict__ == {"c": 42}

{ducktools_classbuilder-0.8.3 → ducktools_classbuilder-0.9.0}/tests/test_core.py

@@ -19,7 +19,6 @@ from ducktools.classbuilder import (
     slot_gatherer,
     slotclass,
 
-    AnnotationClass,
     Field,
     GatheredFields,
     GeneratedCode,
@@ -371,30 +370,6 @@ def test_slotclass_weakref():
     assert ref == inst.__weakref__
 
 
-def test_annotationclass_weakref():
-    import weakref
-
-    class WeakrefClass(AnnotationClass):
-        a: int = 1
-        b: int = 2
-        __weakref__: dict
-
-    flds = get_fields(WeakrefClass)
-    assert 'a' in flds
-    assert 'b' in flds
-    assert '__weakref__' not in flds
-
-    slots = WeakrefClass.__slots__
-    assert 'a' in slots
-    assert 'b' in slots
-    assert '__weakref__' in slots
-
-    # Test weakrefs can be created
-    inst = WeakrefClass()
-    ref = weakref.ref(inst)
-    assert ref == inst.__weakref__
-
-
 def test_slotclass_dict():
     @slotclass
     class DictClass:
@@ -420,28 +395,6 @@ def test_slotclass_dict():
     assert inst.__dict__ == {"c": 42}
 
 
-def test_annotationclass_dict():
-    class DictClass(AnnotationClass):
-        a: int = 1
-        b: int = 2
-        __dict__: dict
-
-    flds = get_fields(DictClass)
-    assert 'a' in flds
-    assert 'b' in flds
-    assert '__dict__' not in flds
-
-    slots = DictClass.__slots__
-    assert 'a' in slots
-    assert 'b' in slots
-    assert '__dict__' in slots
-
-    # Test if __dict__ is included new values can be added
-    inst = DictClass()
-    inst.c = 42
-    assert inst.__dict__ == {"c": 42}
-
-
 def test_fieldclass():
     class NewField(Field):
         serialize: bool = True

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

@@ -1,2 +0,0 @@
-__version__ = "0.8.3"
-__version_tuple__ = (0, 8, 3)