ducktools-classbuilder 0.10.2__py3-none-any.whl → 0.11.0__py3-none-any.whl

ducktools/classbuilder/__init__.py

@@ -31,9 +31,20 @@
 # Field itself sidesteps this by defining __slots__ to avoid that branch.
 
 import os
-import sys
 
-from .annotations import get_ns_annotations, is_classvar, make_annotate_func
+try:
+    # Use the internal C module if it is available
+    from _types import (  # type: ignore
+        MemberDescriptorType as _MemberDescriptorType,
+        MappingProxyType as _MappingProxyType
+    )
+except ImportError:
+    from types import (
+        MemberDescriptorType as _MemberDescriptorType,
+        MappingProxyType as _MappingProxyType,
+    )
+
+from .annotations import get_ns_annotations, is_classvar
 from ._version import __version__, __version_tuple__  # noqa: F401
 
 # Change this name if you make heavy modifications
@@ -45,13 +56,6 @@ GATHERED_DATA = "__classbuilder_gathered_fields__"
 # overwritten. When running this is a performance penalty so it is not required.
 _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)  # type: ignore
-_MappingProxyType = type(type.__dict__)
-del _C
-
 
 def get_fields(cls, *, local=False):
     """
@@ -88,6 +92,20 @@ def get_methods(cls):
     return getattr(cls, INTERNALS_DICT)["methods"]
 
 
+def build_completed(ns):
+    """
+    Utility function to determine if a class has completed the construction
+    process.
+
+    :param ns: class namespace
+    :return: True if built, False otherwise
+    """
+    try:
+        return ns[INTERNALS_DICT]["build_complete"]
+    except KeyError:
+        return False
+
+
 def _get_inst_fields(inst):
     # This is an internal helper for constructing new
     # 'Field' instances from existing ones.
@@ -148,8 +166,14 @@ class GeneratedCode:
 
     def __eq__(self, other):
         if self.__class__ is other.__class__:
-            return (self.source_code, self.globs, self.annotations) == (
-                other.source_code, other.globs, other.annotations
+            return (
+                self.source_code,
+                self.globs,
+                self.annotations,
+                ) == (
+                other.source_code,
+                other.globs,
+                other.annotations,
             )
         return NotImplemented
 
@@ -208,17 +232,7 @@ class MethodMaker:
 
         # Apply annotations
         if gen.annotations is not None:
-            if sys.version_info >= (3, 14):
-                # If __annotations__ exists on the class, either they
-                # are user defined or they are using __future__ annotations.
-                # In this case, just write __annotations__
-                if "__annotations__" in gen_cls.__dict__:
-                    method.__annotations__ = gen.annotations
-                else:
-                    anno_func = make_annotate_func(gen.annotations)
-                    method.__annotate__ = anno_func
-            else:
-                method.__annotations__ = gen.annotations
+            method.__annotations__ = gen.annotations
 
         # Replace this descriptor on the class with the generated function
         setattr(gen_cls, self.funcname, method)
@@ -515,6 +529,9 @@ def builder(cls=None, /, *, gatherer, methods, flags=None, fix_signature=True):
     """
     The main builder for class generation
 
+    If the GATHERED_DATA attribute exists on the class it will be used instead of
+    the provided gatherer.
+
     :param cls: Class to be analysed and have methods generated
     :param gatherer: Function to gather field information
     :type gatherer: Callable[[type], tuple[dict[str, Field], dict[str, Any]]]
@@ -535,12 +552,25 @@ def builder(cls=None, /, *, gatherer, methods, flags=None, fix_signature=True):
             gatherer=gatherer,
             methods=methods,
             flags=flags,
+            fix_signature=fix_signature,
         )
 
-    internals = {}
+    # Get from the class dict to avoid getting an inherited internals dict
+    internals = cls.__dict__.get(INTERNALS_DICT, {})
     setattr(cls, INTERNALS_DICT, internals)
 
-    cls_fields, modifications = gatherer(cls)
+    # Update or add flags to internals dict
+    flag_dict = internals.get("flags", {})
+    if flags is not None:
+        flag_dict.update(flags)
+    internals["flags"] = flag_dict
+
+    cls_gathered = cls.__dict__.get(GATHERED_DATA)
+
+    if cls_gathered:
+        cls_fields, modifications = cls_gathered
+    else:
+        cls_fields, modifications = gatherer(cls)
 
     for name, value in modifications.items():
         if value is NOTHING:
@@ -558,11 +588,10 @@ def builder(cls=None, /, *, gatherer, methods, flags=None, fix_signature=True):
         for c in reversed(mro):
             try:
                 fields.update(get_fields(c, local=True))
-            except AttributeError:
+            except (AttributeError, KeyError):
                 pass
 
     internals["fields"] = fields
-    internals["flags"] = flags if flags is not None else {}
 
     # Assign all of the method generators
     internal_methods = {}
@@ -576,6 +605,9 @@ def builder(cls=None, /, *, gatherer, methods, flags=None, fix_signature=True):
     if fix_signature:
         setattr(cls, "__signature__", signature_maker)
 
+    # Add attribute indicating build completed
+    internals["build_complete"] = True
+
     return cls
 
 
@@ -604,7 +636,35 @@ class SlotMakerMeta(type):
 
     Will not convert `ClassVar` hinted values.
     """
-    def __new__(cls, name, bases, ns, slots=True, gatherer=None, **kwargs):
+    def __new__(
+        cls,
+        name,
+        bases,
+        ns,
+        slots=True,
+        gatherer=None,
+        ignore_annotations=None,
+        **kwargs
+    ):
+
+        # Slot makers should inherit flags
+        for base in bases:
+            try:
+                flags = getattr(base, INTERNALS_DICT)["flags"].copy()
+            except (AttributeError, KeyError):
+                pass
+            else:
+                break
+        else:
+            flags = {"ignore_annotations": False}
+
+        # Set up flags as these may be needed early
+        if ignore_annotations is not None:
+            flags["ignore_annotations"] = ignore_annotations
+
+        # Assign flags to internals
+        ns[INTERNALS_DICT] = {"flags": flags}
+
         # This should only run if slots=True is declared
         # and __slots__ have not already been defined
         if slots and "__slots__" not in ns:
@@ -632,16 +692,16 @@ class SlotMakerMeta(type):
                 else:
                     ns[k] = v
 
-            slots = {}
+            slot_values = {}
             fields = {}
 
             for k, v in cls_fields.items():
-                slots[k] = v.doc
+                slot_values[k] = v.doc
                 if k not in {"__weakref__", "__dict__"}:
                     fields[k] = v
 
             # Place slots *after* everything else to be safe
-            ns["__slots__"] = slots
+            ns["__slots__"] = slot_values
 
             # Place pre-gathered field data - modifications are already applied
             modifications = {}
@@ -811,7 +871,7 @@ def _build_field():
         "init": Field(default=True, doc=field_docs["init"]),
         "repr": Field(default=True, doc=field_docs["repr"]),
         "compare": Field(default=True, doc=field_docs["compare"]),
-        "kw_only": Field(default=False, doc=field_docs["kw_only"])
+        "kw_only": Field(default=False, doc=field_docs["kw_only"]),
     }
     modifications = {"__slots__": field_docs}
 
@@ -831,21 +891,6 @@ _build_field()
 del _build_field
 
 
-def pre_gathered_gatherer(cls_or_ns):
-    """
-    Retrieve fields previously gathered by SlotMakerMeta
-
-    :param cls_or_ns: Class to gather field information from (or class namespace)
-    :return: dict of field_name: Field(...) and modifications to be performed by the builder
-    """
-    if isinstance(cls_or_ns, (_MappingProxyType, dict)):
-        cls_dict = cls_or_ns
-    else:
-        cls_dict = cls_or_ns.__dict__
-
-    return cls_dict[GATHERED_DATA]
-
-
 def make_slot_gatherer(field_type=Field):
     """
     Create a new annotation gatherer that will work with `Field` instances
@@ -928,8 +973,10 @@ def make_annotation_gatherer(
     """
     def field_annotation_gatherer(cls_or_ns):
         if isinstance(cls_or_ns, (_MappingProxyType, dict)):
+            cls = None
             cls_dict = cls_or_ns
         else:
+            cls = cls_or_ns
             cls_dict = cls_or_ns.__dict__
 
         # This should really be dict[str, field_type] but static analysis
@@ -937,7 +984,7 @@ def make_annotation_gatherer(
         cls_fields: dict[str, Field] = {}
         modifications = {}
 
-        cls_annotations = get_ns_annotations(cls_dict)
+        cls_annotations = get_ns_annotations(cls_dict, cls=cls)
 
         kw_flag = False
 
@@ -946,7 +993,7 @@ def make_annotation_gatherer(
             if is_classvar(v):
                 continue
 
-            if v is KW_ONLY or (isinstance(v, str) and v == "KW_ONLY"):
+            if v is KW_ONLY or (isinstance(v, str) and "KW_ONLY" in v):
                 if kw_flag:
                     raise SyntaxError("KW_ONLY sentinel may only appear once.")
                 kw_flag = True
@@ -984,13 +1031,14 @@ def make_annotation_gatherer(
 def make_field_gatherer(
     field_type=Field,
     leave_default_values=False,
-    assign_types=True,
 ):
     def field_attribute_gatherer(cls_or_ns):
         if isinstance(cls_or_ns, (_MappingProxyType, dict)):
             cls_dict = cls_or_ns
+            cls = None
         else:
             cls_dict = cls_or_ns.__dict__
+            cls = cls_or_ns
 
         cls_attributes = {
             k: v
@@ -998,11 +1046,6 @@ def make_field_gatherer(
             if isinstance(v, field_type)
         }
 
-        if assign_types:
-            cls_annotations = get_ns_annotations(cls_dict)
-        else:
-            cls_annotations = {}
-
         cls_modifications = {}
 
         for name in cls_attributes.keys():
@@ -1012,9 +1055,6 @@ def make_field_gatherer(
             else:
                 cls_modifications[name] = NOTHING
 
-            if assign_types and (anno := cls_annotations.get(name, NOTHING)) is not NOTHING:
-                cls_attributes[name] = field_type.from_field(attrib, type=anno)
-
         return cls_attributes, cls_modifications
     return field_attribute_gatherer
 
@@ -1022,7 +1062,6 @@ def make_field_gatherer(
 def make_unified_gatherer(
     field_type=Field,
     leave_default_values=False,
-    ignore_annotations=False,
 ):
     """
     Create a gatherer that will work via first slots, then
@@ -1031,7 +1070,6 @@ def make_unified_gatherer(
 
     :param field_type: The field class to use for gathering
     :param leave_default_values: leave default values in place
-    :param ignore_annotations: don't attempt to read annotations
     :return: gatherer function
     """
     slot_g = make_slot_gatherer(field_type)
@@ -1041,25 +1079,26 @@ def make_unified_gatherer(
     def field_unified_gatherer(cls_or_ns):
         if isinstance(cls_or_ns, (_MappingProxyType, dict)):
             cls_dict = cls_or_ns
+            cls = None
         else:
             cls_dict = cls_or_ns.__dict__
-
-        cls_gathered = cls_dict.get(GATHERED_DATA)
-        if cls_gathered:
-            return pre_gathered_gatherer(cls_dict)
+            cls = cls_or_ns
 
         cls_slots = cls_dict.get("__slots__")
 
         if isinstance(cls_slots, SlotFields):
             return slot_g(cls_dict)
 
+        # Get ignore_annotations flag
+        ignore_annotations = cls_dict.get(INTERNALS_DICT, {}).get("flags", {}).get("ignore_annotations", False)
+
         if ignore_annotations:
             return attrib_g(cls_dict)
         else:
             # To choose between annotation and attribute gatherers
             # compare sets of names.
             # Don't bother evaluating string annotations, as we only need names
-            cls_annotations = get_ns_annotations(cls_dict)
+            cls_annotations = get_ns_annotations(cls_dict, cls=cls)
             cls_attributes = {
                 k: v for k, v in cls_dict.items() if isinstance(v, field_type)
             }
@@ -1069,7 +1108,9 @@ def make_unified_gatherer(
 
             if set(cls_annotation_names).issuperset(set(cls_attribute_names)):
                 # All `Field` values have annotations, so use annotation gatherer
-                return anno_g(cls_dict)
+                # Pass the original cls_or_ns object
+
+                return anno_g(cls_or_ns)
 
             return attrib_g(cls_dict)
 

ducktools/classbuilder/__init__.pyi

@@ -1,13 +1,19 @@
+import sys
 import types
 import typing
 import typing_extensions
 
-import inspect
 
 from collections.abc import Callable
 from types import MappingProxyType
 
-_py_type = type | str  # Alias for type hint values
+if sys.version_info >= (3, 14):
+    import annotationlib
+
+    _py_type = annotationlib.ForwardRef | type | str
+else:
+    _py_type = type | str
+
 _CopiableMappings = dict[str, typing.Any] | MappingProxyType[str, typing.Any]
 
 __version__: str
@@ -22,6 +28,8 @@ def get_flags(cls: type) -> dict[str, bool]: ...
 
 def get_methods(cls: type) -> types.MappingProxyType[str, MethodMaker]: ...
 
+def build_completed(ns: _CopiableMappings) -> bool: ...
+
 def _get_inst_fields(inst: typing.Any) -> dict[str, typing.Any]: ...
 
 class _NothingType:
@@ -130,6 +138,7 @@ class SlotMakerMeta(type):
         ns: dict[str, typing.Any],
         slots: bool = ...,
         gatherer: Callable[[type], tuple[dict[str, Field], dict[str, typing.Any]]] | None = ...,
+        ignore_annotations: bool | None = ...,
         **kwargs: typing.Any,
     ) -> _T: ...
 
@@ -168,16 +177,11 @@ class Field(metaclass=SlotMakerMeta):
     @classmethod
     def from_field(cls, fld: Field, /, **kwargs: typing.Any) -> Field: ...
 
-
 # type[Field] doesn't work due to metaclass
 # This is not really precise enough because isinstance is used
 _ReturnsField = Callable[..., Field]
 _FieldType = typing.TypeVar("_FieldType", bound=Field)
 
-def pre_gathered_gatherer(
-    cls_or_ns: type | _CopiableMappings
-) -> tuple[dict[str, Field | _FieldType], dict[str, typing.Any]]: ...
-
 @typing.overload
 def make_slot_gatherer(
     field_type: type[_FieldType]
@@ -204,7 +208,6 @@ def make_annotation_gatherer(
 def make_field_gatherer(
     field_type: type[_FieldType],
     leave_default_values: bool = False,
-    assign_types: bool = True,
 ) -> Callable[[type | _CopiableMappings], tuple[dict[str, _FieldType], dict[str, typing.Any]]]: ...
 
 @typing.overload
@@ -217,14 +220,12 @@ def make_field_gatherer(
 def make_unified_gatherer(
     field_type: type[_FieldType],
     leave_default_values: bool = ...,
-    ignore_annotations: bool = ...,
 ) -> Callable[[type | _CopiableMappings], tuple[dict[str, _FieldType], dict[str, typing.Any]]]: ...
 
 @typing.overload
 def make_unified_gatherer(
     field_type: _ReturnsField = ...,
     leave_default_values: bool = ...,
-    ignore_annotations: bool = ...,
 ) -> Callable[[type | _CopiableMappings], tuple[dict[str, Field], dict[str, typing.Any]]]: ...
 
 
@@ -263,9 +264,6 @@ class GatheredFields:
     fields: dict[str, Field]
     modifications: dict[str, typing.Any]
 
-    __classbuilder_internals__: dict
-    __signature__: inspect.Signature
-
     def __init__(
         self,
         fields: dict[str, Field],

ducktools/classbuilder/_version.py

@@ -1,2 +1,2 @@
-__version__ = "0.10.2"
-__version_tuple__ = (0, 10, 2)
+__version__ = "0.11.0"
+__version_tuple__ = (0, 11, 0)

ducktools/classbuilder/annotations/__init__.py

@@ -0,0 +1,63 @@
+# MIT License
+#
+# Copyright (c) 2024 David C Ellis
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# 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.
+
+import sys
+
+if sys.version_info >= (3, 14):
+    from .annotations_314 import (
+        get_func_annotations,
+        get_ns_annotations,
+    )
+else:
+    from .annotations_pre_314 import (
+        get_func_annotations,
+        get_ns_annotations,
+    )
+
+
+__all__ = [
+    "get_func_annotations",
+    "get_ns_annotations",
+    "is_classvar",
+]
+
+
+def is_classvar(hint):
+    if isinstance(hint, str):
+        # String annotations, just check if the string 'ClassVar' is in there
+        # This is overly broad and could be smarter.
+        return "ClassVar" in hint
+    else:
+        _typing = sys.modules.get("typing")
+        if _typing:
+            _Annotated = _typing.Annotated
+            _get_origin = _typing.get_origin
+
+            if _Annotated and _get_origin(hint) is _Annotated:
+                hint = getattr(hint, "__origin__", None)
+
+            if (
+                hint is _typing.ClassVar
+                or getattr(hint, "__origin__", None) is _typing.ClassVar
+            ):
+                return True
+    return False

ducktools/classbuilder/annotations/annotations_314.py

@@ -0,0 +1,104 @@
+# MIT License
+#
+# Copyright (c) 2024 David C Ellis
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# 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.
+
+"""
+Python 3.14 has new annotations methods, but does not provide any correct way to handle VALUE
+annotation generation for new __init__ methods.
+
+The approach taken here is to try to use VALUE annotations, if those fail it falls back to
+STRING annotations, as if __future__ annotations actually arrived.
+
+Hopefully in a future version of Python we will have complete, correct, performant annotations
+so we can use a more standard format.
+"""
+
+class _LazyAnnotationLib:
+    def __getattr__(self, item):
+        global _lazy_annotationlib
+        import annotationlib  # type: ignore
+        _lazy_annotationlib = annotationlib
+        return getattr(annotationlib, item)
+
+
+_lazy_annotationlib = _LazyAnnotationLib()
+
+
+def get_func_annotations(func, use_forwardref=False):
+    """
+    Given a function, return the annotations dictionary
+
+    :param func: function object
+    :return: dictionary of annotations
+    """
+    # Try to get `__annotations__` for VALUE annotations first
+    try:
+        raw_annotations = func.__annotations__
+    except Exception:
+        fmt = (
+            _lazy_annotationlib.Format.FORWARDREF
+            if use_forwardref
+            else _lazy_annotationlib.Format.STRING
+        )
+        annotations = _lazy_annotationlib.get_annotations(func, format=fmt)
+    else:
+        annotations = raw_annotations.copy()
+
+    return annotations
+
+
+def get_ns_annotations(ns, cls=None, use_forwardref=False):
+    """
+    Given a class namespace, attempt to retrieve the
+    annotations dictionary.
+
+    :param ns: Class namespace (eg cls.__dict__)
+    :param cls: Class if available
+    :param use_forwardref: Use FORWARDREF instead of STRING if VALUE fails
+    :return: dictionary of annotations
+    """
+
+    annotations = ns.get("__annotations__")
+    if annotations is not None:
+        annotations = annotations.copy()
+    else:
+        # See if we're using PEP-649 annotations
+        annotate = _lazy_annotationlib.get_annotate_from_class_namespace(ns)
+        if annotate:
+            try:
+                annotations = annotate(_lazy_annotationlib.Format.VALUE)
+            except Exception:
+                fmt = (
+                    _lazy_annotationlib.Format.FORWARDREF
+                    if use_forwardref
+                    else _lazy_annotationlib.Format.STRING
+                )
+
+                annotations = _lazy_annotationlib.call_annotate_function(
+                    annotate,
+                    format=fmt,
+                    owner=cls
+                )
+
+    if annotations is None:
+        annotations = {}
+
+    return annotations

ducktools/classbuilder/annotations/annotations_pre_314.py

@@ -0,0 +1,42 @@
+# MIT License
+#
+# Copyright (c) 2024 David C Ellis
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# 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.
+
+def get_func_annotations(func, use_forwardref=False):
+    """
+    Given a function, return the annotations dictionary
+
+    :param func: function object
+    :return: dictionary of annotations
+    """
+    annotations = func.__annotations__
+    return annotations
+
+
+# This is simplified under 3.13 or earlier
+def get_ns_annotations(ns, cls=None, use_forwardref=False):
+    annotations = ns.get("__annotations__")
+    if annotations is not None:
+        annotations = annotations.copy()
+    else:
+        annotations = {}
+    return annotations
+

ducktools/classbuilder/annotations.pyi

@@ -1,21 +1,21 @@
 from collections.abc import Callable
 import typing
 import types
+import sys
 
 _CopiableMappings = dict[str, typing.Any] | types.MappingProxyType[str, typing.Any]
 
 def get_func_annotations(
     func: types.FunctionType,
+    use_forwardref: bool = ...,
 ) -> dict[str, typing.Any]: ...
 
 def get_ns_annotations(
     ns: _CopiableMappings,
+    cls: type | None = ...,
+    use_forwardref: bool = ...,
 ) -> dict[str, typing.Any]: ...
 
-def make_annotate_func(
-    annos: dict[str, typing.Any]
-) -> Callable[[int], dict[str, typing.Any]]: ...
-
 def is_classvar(
     hint: object,
 ) -> bool: ...

ducktools/classbuilder/prefab.py

@@ -32,13 +32,13 @@ from . import (
     make_unified_gatherer,
     eq_maker, frozen_setattr_maker, frozen_delattr_maker, replace_maker,
     get_repr_generator,
+    build_completed,
 )
 
 from .annotations import get_func_annotations
 
 # These aren't used but are re-exported for ease of use
-# noinspection PyUnresolvedReferences
-from . import SlotFields, KW_ONLY  # noqa: F401
+from . import SlotFields as SlotFields, KW_ONLY as KW_ONLY
 
 PREFAB_FIELDS = "PREFAB_FIELDS"
 PREFAB_INIT_FUNC = "__prefab_init__"
@@ -327,7 +327,7 @@ def attribute(
     :param private: Short for init, repr, compare, iter, serialize = False, must have default or factory
     :param doc: Parameter documentation for slotted classes
     :param metadata: Dictionary for additional non-construction metadata
-    :param type: Type of this attribute (for slotted classes)
+    :param type: Type of this attribute
 
     :return: Attribute generated with these parameters.
     """
@@ -361,7 +361,10 @@ def attribute(
     )
 
 
-prefab_gatherer = make_unified_gatherer(Attribute, False)
+prefab_gatherer = make_unified_gatherer(
+    Attribute,
+    leave_default_values=False,
+)
 
 
 # Class Builders
@@ -376,9 +379,11 @@ def _make_prefab(
     match_args=True,
     kw_only=False,
     frozen=False,
+    replace=True,
     dict_method=False,
     recursive_repr=False,
     gathered_fields=None,
+    ignore_annotations=False,
 ):
     """
     Generate boilerplate code for dunder methods in a class.
@@ -393,21 +398,22 @@ def _make_prefab(
     :param frozen: Prevent attribute values from being changed once defined
                    (This does not prevent the modification of mutable attributes
                    such as lists)
+    :param replace: Add a generated __replace__ method
     :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
+    :param ignore_annotations: Ignore annotated fields and only look at `attribute` fields
     :return: class with __ methods defined
     """
     cls_dict = cls.__dict__
 
-    if INTERNALS_DICT in cls_dict:
+    if build_completed(cls_dict):
         raise PrefabError(
             f"Decorated class {cls.__name__!r} "
             f"has already been processed as a Prefab."
         )
 
     slots = cls_dict.get("__slots__")
-
     slotted = False if slots is None else True
 
     if gathered_fields is None:
@@ -438,11 +444,22 @@ def _make_prefab(
     if dict_method:
         methods.add(asdict_maker)
 
-    methods.add(replace_maker)
+    if replace and "__replace__" not in cls_dict:
+        methods.add(replace_maker)
 
     flags = {
-        "kw_only": kw_only,
         "slotted": slotted,
+        "init": init,
+        "repr": repr,
+        "eq": eq,
+        "iter": iter,
+        "match_args": match_args,
+        "kw_only": kw_only,
+        "frozen": frozen,
+        "replace": replace,
+        "dict_method": dict_method,
+        "recursive_repr": recursive_repr,
+        "ignore_annotations": ignore_annotations,
     }
 
     cls = builder(
@@ -551,30 +568,71 @@ def _make_prefab(
 class Prefab(metaclass=SlotMakerMeta, gatherer=prefab_gatherer):
     __slots__ = {}  # type: ignore
 
-    # 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,
+        **kwargs
     ):
+        """
+        Generate boilerplate code for dunder methods in a class.
+
+        Use as a base class, slotted by default
+
+        :param init: generates __init__ if true or __prefab_init__ if false
+        :param repr: generate __repr__
+        :param eq: generate __eq__
+        :param iter: generate __iter__
+        :param match_args: generate __match_args__
+        :param kw_only: make all attributes keyword only
+        :param frozen: Prevent attribute values from being changed once defined
+                    (This does not prevent the modification of mutable attributes such as lists)
+        :param replace: generate a __replace__ method
+        :param dict_method: Include an as_dict method for faster dictionary creation
+        :param recursive_repr: Safely handle repr in case of recursion
+        :param ignore_annotations: Ignore type annotations when gathering fields, only look for
+                                slots or attribute(...) values
+        :param slots: automatically generate slots for this class's attributes
+        """
+        default_values = {
+            "init": True,
+            "repr": True,
+            "eq": True,
+            "iter": False,
+            "match_args": True,
+            "kw_only": False,
+            "frozen": False,
+            "replace": True,
+            "dict_method": False,
+            "recursive_repr": False,
+        }
+
+        try:
+            flags = get_flags(cls).copy()
+        except (AttributeError, KeyError):
+            flags = {}
+        else:
+            # Remove the value of slotted if it exists
+            flags.pop("slotted", None)
+
+        for k in default_values:
+            kwarg_value = kwargs.pop(k, None)
+            default = default_values[k]
+
+            if kwarg_value is not None:
+                flags[k] = kwarg_value
+            elif flags.get(k) is None:
+                flags[k] = default
+
+        if kwargs:
+            error_args = ", ".join(repr(k) for k in kwargs)
+            raise TypeError(
+                f"Prefab.__init_subclass__ got unexpected keyword arguments {error_args}"
+            )
+
+        print(flags)
+
         _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,
+            **flags
         )
 
 
@@ -589,8 +647,10 @@ def prefab(
     match_args=True,
     kw_only=False,
     frozen=False,
+    replace=True,
     dict_method=False,
     recursive_repr=False,
+    ignore_annotations=False,
 ):
     """
     Generate boilerplate code for dunder methods in a class.
@@ -606,8 +666,11 @@ def prefab(
     :param kw_only: make all attributes keyword only
     :param frozen: Prevent attribute values from being changed once defined
                    (This does not prevent the modification of mutable attributes such as lists)
+    :param replace: generate a __replace__ method
     :param dict_method: Include an as_dict method for faster dictionary creation
     :param recursive_repr: Safely handle repr in case of recursion
+    :param ignore_annotations: Ignore type annotations when gathering fields, only look for
+                               slots or attribute(...) values
 
     :return: class with __ methods defined
     """
@@ -622,8 +685,10 @@ def prefab(
             match_args=match_args,
             kw_only=kw_only,
             frozen=frozen,
+            replace=replace,
             dict_method=dict_method,
             recursive_repr=recursive_repr,
+            ignore_annotations=ignore_annotations,
         )
     else:
         return _make_prefab(
@@ -635,8 +700,10 @@ def prefab(
             match_args=match_args,
             kw_only=kw_only,
             frozen=frozen,
+            replace=replace,
             dict_method=dict_method,
             recursive_repr=recursive_repr,
+            ignore_annotations=ignore_annotations,
         )
 
 
@@ -654,6 +721,7 @@ def build_prefab(
     match_args=True,
     kw_only=False,
     frozen=False,
+    replace=True,
     dict_method=False,
     recursive_repr=False,
     slots=False,
@@ -675,6 +743,7 @@ def build_prefab(
     :param kw_only: make all attributes keyword only
     :param frozen: Prevent attribute values from being changed once defined
                    (This does not prevent the modification of mutable attributes such as lists)
+    :param replace: generate a __replace__ method
     :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
@@ -703,6 +772,7 @@ def build_prefab(
         class_dict["__slots__"] = class_slots
 
     class_dict["__annotations__"] = class_annotations
+
     cls = type(class_name, bases, class_dict)
 
     gathered_fields = GatheredFields(fields, {})
@@ -716,6 +786,7 @@ def build_prefab(
         match_args=match_args,
         kw_only=kw_only,
         frozen=frozen,
+        replace=replace,
         dict_method=dict_method,
         recursive_repr=recursive_repr,
         gathered_fields=gathered_fields,
@@ -779,6 +850,17 @@ def as_dict(o):
     }
 
 def replace(obj, /, **changes):
+    """
+    Create a copy of a prefab instance with values provided to 'changes' replaced
+
+    :param obj: prefab instance
+    :return: new prefab instance
+    """
     if not is_prefab_instance(obj):
         raise TypeError("replace() should be called on prefab instances")
-    return obj.__replace__(**changes)
+    try:
+        replace_func = obj.__replace__
+    except AttributeError:
+        raise TypeError(f"{obj.__class__.__name__!r} does not support __replace__")
+
+    return replace_func(**changes)

ducktools/classbuilder/prefab.pyi

@@ -2,7 +2,6 @@ import typing
 from types import MappingProxyType
 from typing_extensions import dataclass_transform
 
-import inspect
 
 # Suppress weird pylance error
 from collections.abc import Callable  # type: ignore
@@ -141,9 +140,11 @@ def _make_prefab(
     match_args: bool = True,
     kw_only: bool = False,
     frozen: bool = False,
+    replace: bool = True,
     dict_method: bool = False,
     recursive_repr: bool = False,
     gathered_fields: Callable[[type], tuple[dict[str, Attribute], dict[str, typing.Any]]] | None = None,
+    ignore_annotations: bool = False,
 ) -> type: ...
 
 _T = typing.TypeVar("_T")
@@ -151,10 +152,12 @@ _T = typing.TypeVar("_T")
 # noinspection PyUnresolvedReferences
 @dataclass_transform(field_specifiers=(Attribute, attribute))
 class Prefab(metaclass=SlotMakerMeta):
+    __classbuilder_internals__: 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,
         repr: bool = True,
         eq: bool = True,
@@ -162,6 +165,7 @@ class Prefab(metaclass=SlotMakerMeta):
         match_args: bool = True,
         kw_only: bool = False,
         frozen: bool = False,
+        replace: bool = True,
         dict_method: bool = False,
         recursive_repr: bool = False,
     ) -> None: ...
@@ -213,8 +217,10 @@ def prefab(
     match_args: bool = ...,
     kw_only: bool = ...,
     frozen: bool = ...,
+    replace: bool = ...,
     dict_method: bool = ...,
     recursive_repr: bool = ...,
+    ignore_annotations: bool = ...,
 ) -> typing.Any: ...
 
 def build_prefab(
@@ -230,6 +236,7 @@ def build_prefab(
     match_args: bool = True,
     kw_only: bool = False,
     frozen: bool = False,
+    replace: bool = True,
     dict_method: bool = False,
     recursive_repr: bool = False,
     slots: bool = False,

{ducktools_classbuilder-0.10.2.dist-info → ducktools_classbuilder-0.11.0.dist-info}/METADATA

@@ -1,8 +1,9 @@
 Metadata-Version: 2.4
 Name: ducktools-classbuilder
-Version: 0.10.2
+Version: 0.11.0
 Summary: Toolkit for creating class boilerplate generators
 Author: David C Ellis
+License-Expression: MIT
 Project-URL: Homepage, https://github.com/davidcellis/ducktools-classbuilder
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python :: 3.10
@@ -11,7 +12,6 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Operating System :: OS Independent
-Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE

ducktools_classbuilder-0.11.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+ducktools/classbuilder/__init__.py,sha256=MnzhfqFtCvrjXaEgl23bpqNdcnYo2gDcJ2NJ4tZoAb4,38774
+ducktools/classbuilder/__init__.pyi,sha256=K-M3seIjYBdp5LV5q-rsPmFnd7XriUAh6yt6kDGJHRQ,8177
+ducktools/classbuilder/_version.py,sha256=XCxV77c5KfBMiOfJNfOT2ca4mIptAMbl0__7iQH-pMY,54
+ducktools/classbuilder/annotations.pyi,sha256=bKTwQlPydbwrbVGaDu_PoSYOhuaqv8I_tMHf-g4aT0M,476
+ducktools/classbuilder/prefab.py,sha256=KoRvTZyW7hAS0w8pzRho3FzRvzE9ztuWutHbKOscB_0,27391
+ducktools/classbuilder/prefab.pyi,sha256=_cg9WsZqwkgOy0iowHtzGB2E6BSNJdKcdk0IC_Wz_qU,6756
+ducktools/classbuilder/py.typed,sha256=la67KBlbjXN-_-DfGNcdOcjYumVpKG_Tkw-8n5dnGB4,8
+ducktools/classbuilder/annotations/__init__.py,sha256=n8VFmOItEbsMuq5gothp5yi6H3m3JJdVys04DVb0r-4,2145
+ducktools/classbuilder/annotations/annotations_314.py,sha256=Yeng_kke1dcE6RarOzYN7SczWc9TSQEEZFEODzSj4uo,3692
+ducktools/classbuilder/annotations/annotations_pre_314.py,sha256=Et-TYQYNVtMssShsS62PTu2mou2kr-ZJldYAAayhjAU,1651
+ducktools_classbuilder-0.11.0.dist-info/licenses/LICENSE,sha256=6Thz9Dbw8R4fWInl6sGl8Rj3UnKnRbDwrc6jZerpugQ,1070
+ducktools_classbuilder-0.11.0.dist-info/METADATA,sha256=WnqrTjsS__wBR6uCDIqVPjairFcyjj_zP8KwwrCLCgw,9204
+ducktools_classbuilder-0.11.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ducktools_classbuilder-0.11.0.dist-info/top_level.txt,sha256=uSDLtio3ZFqdwcsMJ2O5yhjB4Q3ytbBWbA8rJREganc,10
+ducktools_classbuilder-0.11.0.dist-info/RECORD,,

ducktools/classbuilder/annotations.py

@@ -1,137 +0,0 @@
-# MIT License
-#
-# Copyright (c) 2024 David C Ellis
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all
-# copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# 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.
-import sys
-
-
-class _LazyAnnotationLib:
-    def __getattr__(self, item):
-        global _lazy_annotationlib
-        import annotationlib  # type: ignore
-        _lazy_annotationlib = annotationlib
-        return getattr(annotationlib, item)
-
-
-_lazy_annotationlib = _LazyAnnotationLib()
-
-
-def get_func_annotations(func):
-    """
-    Given a function, return the annotations dictionary
-
-    :param func: function object
-    :return: dictionary of annotations
-    """
-    # This method exists for use by prefab in getting annotations from
-    # the __prefab_post_init__ function
-    try:
-        annotations = func.__annotations__
-    except Exception:
-        if sys.version_info >= (3, 14):
-            annotations = _lazy_annotationlib.get_annotations(
-                func,
-                format=_lazy_annotationlib.Format.FORWARDREF,
-            )
-        else:
-            raise
-
-    return annotations
-
-
-def get_ns_annotations(ns):
-    """
-    Given a class namespace, attempt to retrieve the
-    annotations dictionary.
-
-    :param ns: Class namespace (eg cls.__dict__)
-    :return: dictionary of annotations
-    """
-
-    annotations = ns.get("__annotations__")
-    if annotations is not None:
-        annotations = annotations.copy()
-    elif sys.version_info >= (3, 14):
-        # See if we're using PEP-649 annotations
-        annotate = _lazy_annotationlib.get_annotate_from_class_namespace(ns)
-        if annotate:
-            annotations = _lazy_annotationlib.call_annotate_function(
-                annotate,
-                format=_lazy_annotationlib.Format.FORWARDREF
-            )
-
-    if annotations is None:
-        annotations = {}
-
-    return annotations
-
-
-def make_annotate_func(annos):
-    # Only used in 3.14 or later so no sys.version_info gate
-
-    type_repr = _lazy_annotationlib.type_repr
-    Format = _lazy_annotationlib.Format
-    ForwardRef = _lazy_annotationlib.ForwardRef
-    # Construct an annotation function from __annotations__
-    def annotate_func(format, /):
-        match format:
-            case Format.VALUE | Format.FORWARDREF:
-                return {
-                    k: v.evaluate(format=format)
-                    if isinstance(v, ForwardRef) else v
-                    for k, v in annos.items()
-                }
-            case Format.STRING:
-                string_annos = {}
-                for k, v in annos.items():
-                    if isinstance(v, str):
-                        string_annos[k] = v
-                    elif isinstance(v, ForwardRef):
-                        string_annos[k] = v.evaluate(format=Format.STRING)
-                    else:
-                        string_annos[k] = type_repr(v)
-                return string_annos
-            case _:
-                raise NotImplementedError(format)
-    return annotate_func
-
-
-def is_classvar(hint):
-    if isinstance(hint, str):
-        # String annotations, just check if the string 'ClassVar' is in there
-        # This is overly broad and could be smarter.
-        return "ClassVar" in hint
-    elif (annotationlib := sys.modules.get("annotationlib")) and isinstance(hint, annotationlib.ForwardRef):
-        return "ClassVar" in hint.__arg__
-    else:
-        _typing = sys.modules.get("typing")
-        if _typing:
-            _Annotated = _typing.Annotated
-            _get_origin = _typing.get_origin
-
-            if _Annotated and _get_origin(hint) is _Annotated:
-                hint = getattr(hint, "__origin__", None)
-
-            if (
-                hint is _typing.ClassVar
-                or getattr(hint, "__origin__", None) is _typing.ClassVar
-            ):
-                return True
-    return False

ducktools_classbuilder-0.10.2.dist-info/RECORD

@@ -1,13 +0,0 @@
-ducktools/classbuilder/__init__.py,sha256=uTJI45-T5ZENOfN5CqnPJRujendDYwQsu0A-zsOdIho,38198
-ducktools/classbuilder/__init__.pyi,sha256=gL_YMTFovtD0vTPeBH-wkiy_l761bxItruIBRs6Aouw,8302
-ducktools/classbuilder/_version.py,sha256=DH400d3tmKMEKy7OEfbyeJl0NAXPlOLDwet_95nLc-M,54
-ducktools/classbuilder/annotations.py,sha256=JtL8RhNp5hB_dfUju_zsqI19F9yTRQ1uM5ZTpas-VVw,4753
-ducktools/classbuilder/annotations.pyi,sha256=oUTN_ee7DWCz4CI36I7mAD43Bxlz_e5ises_VNnCX9g,480
-ducktools/classbuilder/prefab.py,sha256=UiYBvVSWM4BB4JGwUkYtG9QhPK8TzCYUiey_dgNejo8,24345
-ducktools/classbuilder/prefab.pyi,sha256=eZLjFhM-oHeRBONpCWSb1wLJKGs5Xiq0w_Jeor8Go-w,6525
-ducktools/classbuilder/py.typed,sha256=la67KBlbjXN-_-DfGNcdOcjYumVpKG_Tkw-8n5dnGB4,8
-ducktools_classbuilder-0.10.2.dist-info/licenses/LICENSE,sha256=6Thz9Dbw8R4fWInl6sGl8Rj3UnKnRbDwrc6jZerpugQ,1070
-ducktools_classbuilder-0.10.2.dist-info/METADATA,sha256=bL2jfRX1oqIJGKySrWwdEHsX_8gpOHCFPRy9i66fQnQ,9231
-ducktools_classbuilder-0.10.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ducktools_classbuilder-0.10.2.dist-info/top_level.txt,sha256=uSDLtio3ZFqdwcsMJ2O5yhjB4Q3ytbBWbA8rJREganc,10
-ducktools_classbuilder-0.10.2.dist-info/RECORD,,