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

ducktools/classbuilder/__init__.py

@@ -32,6 +32,18 @@
 
 import os
 
+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
 
@@ -44,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):
     """
@@ -87,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.
@@ -131,19 +150,31 @@ class GeneratedCode:
     This class provides a return value for the generated output from source code
     generators.
     """
-    __slots__ = ("source_code", "globs")
+    __slots__ = ("source_code", "globs", "annotations")
 
-    def __init__(self, source_code, globs):
+    def __init__(self, source_code, globs, annotations=None):
         self.source_code = source_code
         self.globs = globs
+        self.annotations = annotations
 
     def __repr__(self):
         first_source_line = self.source_code.split("\n")[0]
-        return f"GeneratorOutput(source_code='{first_source_line} ...', globs={self.globs!r})"
+        return (
+            f"GeneratorOutput(source_code='{first_source_line} ...', "
+            f"globs={self.globs!r}, annotations={self.annotations!r})"
+        )
 
     def __eq__(self, other):
         if self.__class__ is other.__class__:
-            return (self.source_code, self.globs) == (other.source_code, other.globs)
+            return (
+                self.source_code,
+                self.globs,
+                self.annotations,
+                ) == (
+                other.source_code,
+                other.globs,
+                other.annotations,
+            )
         return NotImplemented
 
 
@@ -199,6 +230,10 @@ class MethodMaker:
             # descriptor. Don't try to rename.
             pass
 
+        # Apply annotations
+        if gen.annotations is not None:
+            method.__annotations__ = gen.annotations
+
         # Replace this descriptor on the class with the generated function
         setattr(gen_cls, self.funcname, method)
 
@@ -494,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]]]
@@ -514,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:
@@ -537,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 = {}
@@ -555,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
 
 
@@ -583,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:
@@ -611,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 = {}
@@ -790,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}
 
@@ -810,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
@@ -907,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
@@ -916,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
 
@@ -925,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
@@ -963,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
@@ -977,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():
@@ -991,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
 
@@ -1001,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
@@ -1010,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)
@@ -1020,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)
             }
@@ -1048,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:
@@ -40,16 +48,20 @@ class KW_ONLY(metaclass=_KW_ONLY_META): ...
 class _CodegenType(typing.Protocol):
     def __call__(self, cls: type, funcname: str = ...) -> GeneratedCode: ...
 
-
 class GeneratedCode:
-    __slots__: tuple[str, str]
+    __slots__: tuple[str, ...]
     source_code: str
     globs: dict[str, typing.Any]
+    annotations: dict[str, typing.Any]
 
-    def __init__(self, source_code: str, globs: dict[str, typing.Any]) -> None: ...
+    def __init__(
+        self,
+        source_code: str,
+        globs: dict[str, typing.Any],
+        annotations: dict[str, typing.Any] | None = ...,
+    ) -> None: ...
     def __repr__(self) -> str: ...
 
-
 class MethodMaker:
     funcname: str
     code_generator: _CodegenType
@@ -126,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: ...
 
@@ -164,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]
@@ -200,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
@@ -213,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]]]: ...
 
 
@@ -259,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.1"
-__version_tuple__ = (0, 10, 1)
+__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.py → annotations/annotations_314.py}

@@ -19,89 +19,86 @@
 # 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
 
+"""
+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 _lazyannotationlib
+        global _lazy_annotationlib
         import annotationlib  # type: ignore
-        _lazyannotationlib = annotationlib
+        _lazy_annotationlib = annotationlib
         return getattr(annotationlib, item)
 
 
 _lazy_annotationlib = _LazyAnnotationLib()
 
 
-def get_func_annotations(func):
+def get_func_annotations(func, use_forwardref=False):
     """
     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 to get `__annotations__` for VALUE annotations first
     try:
-        annotations = func.__annotations__
+        raw_annotations = func.__annotations__
     except Exception:
-        if sys.version_info >= (3, 14):
-            annotations = _lazy_annotationlib.get_annotations(
-                func,
-                format=_lazy_annotationlib.Format.FORWARDREF,
-            )
-        else:
-            raise
+        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):
+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()
-    elif sys.version_info >= (3, 14):
+    else:
         # 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
-            )
+            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
-
-
-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/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,14 +1,19 @@
+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 is_classvar(

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__"
@@ -64,6 +64,7 @@ def get_attributes(cls):
 # Method Generators
 def init_generator(cls, funcname="__init__"):
     globs = {}
+    annotations = {}
     # Get the internals dictionary and prepare attributes
     attributes = get_attributes(cls)
     flags = get_flags(cls)
@@ -106,41 +107,29 @@ def init_generator(cls, funcname="__init__"):
     kw_only_arglist = []
     for name, attrib in attributes.items():
         # post_init annotations can be used to broaden types.
-        if name in post_init_annotations:
-            globs[f"_{name}_type"] = post_init_annotations[name]
-        elif attrib.type is not NOTHING:
-            globs[f"_{name}_type"] = attrib.type
-
         if attrib.init:
+            if name in post_init_annotations:
+                annotations[name] = post_init_annotations[name]
+            elif attrib.type is not NOTHING:
+                annotations[name] = attrib.type
+
             if attrib.default is not NOTHING:
                 if isinstance(attrib.default, (str, int, float, bool)):
                     # Just use the literal in these cases
-                    if attrib.type is NOTHING:
-                        arg = f"{name}={attrib.default!r}"
-                    else:
-                        arg = f"{name}: _{name}_type = {attrib.default!r}"
+                    arg = f"{name}={attrib.default!r}"
                 else:
                     # No guarantee repr will work for other objects
                     # so store the value in a variable and put it
                     # in the globals dict for eval
-                    if attrib.type is NOTHING:
-                        arg = f"{name}=_{name}_default"
-                    else:
-                        arg = f"{name}: _{name}_type = _{name}_default"
+                    arg = f"{name}=_{name}_default"
                     globs[f"_{name}_default"] = attrib.default
             elif attrib.default_factory is not NOTHING:
                 # Use NONE here and call the factory later
                 # This matches the behaviour of compiled
-                if attrib.type is NOTHING:
-                    arg = f"{name}=None"
-                else:
-                    arg = f"{name}: _{name}_type = None"
+                arg = f"{name}=None"
                 globs[f"_{name}_factory"] = attrib.default_factory
             else:
-                if attrib.type is NOTHING:
-                    arg = name
-                else:
-                    arg = f"{name}: _{name}_type"
+                arg = name
             if attrib.kw_only or kw_only:
                 kw_only_arglist.append(arg)
             else:
@@ -206,13 +195,19 @@ def init_generator(cls, funcname="__init__"):
         post_init_call = ""
 
     code = (
-        f"def {funcname}(self, {args}) -> None:\n"
+        f"def {funcname}(self, {args}):\n"
         f"{pre_init_call}\n"
         f"{body}\n"
         f"{post_init_call}\n"
     )
 
-    return GeneratedCode(code, globs)
+    if annotations:
+        annotations["return"] = None
+    else:
+        # If there are no annotations, return an unannotated init function
+        annotations = None
+
+    return GeneratedCode(code, globs, annotations)
 
 
 def iter_generator(cls, funcname="__iter__"):
@@ -332,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.
     """
@@ -366,7 +361,10 @@ def attribute(
     )
 
 
-prefab_gatherer = make_unified_gatherer(Attribute, False)
+prefab_gatherer = make_unified_gatherer(
+    Attribute,
+    leave_default_values=False,
+)
 
 
 # Class Builders
@@ -381,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.
@@ -398,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:
@@ -443,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(
@@ -556,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
         )
 
 
@@ -594,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.
@@ -611,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
     """
@@ -627,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(
@@ -640,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,
         )
 
 
@@ -659,6 +721,7 @@ def build_prefab(
     match_args=True,
     kw_only=False,
     frozen=False,
+    replace=True,
     dict_method=False,
     recursive_repr=False,
     slots=False,
@@ -680,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
@@ -708,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, {})
@@ -721,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,
@@ -784,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.1.dist-info → ducktools_classbuilder-0.11.0.dist-info}/METADATA

@@ -1,8 +1,9 @@
 Metadata-Version: 2.4
 Name: ducktools-classbuilder
-Version: 0.10.1
+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-0.10.1.dist-info/RECORD

@@ -1,13 +0,0 @@
-ducktools/classbuilder/__init__.py,sha256=zJuGJ8_1EPEYJqO0XXDuknwGD1MxPJSZXS5_wFAW6B0,37299
-ducktools/classbuilder/__init__.pyi,sha256=NazFRfLcMpU533jGixaWHV_kARtc9J4-xXX-gkD8rFY,8177
-ducktools/classbuilder/_version.py,sha256=kdUPXlUQWcTv2wnqFkwrCx7Ue7WU2JVPnG1UU0gmLck,54
-ducktools/classbuilder/annotations.py,sha256=ImEEuzEFUrGNRMlAl7YN-H8PZT1FOK8D_yL1LygNdmo,3626
-ducktools/classbuilder/annotations.pyi,sha256=zAKJbEN1klvZu71ShuvKbf6OE7ddKb5USC6MbOjRPfY,336
-ducktools/classbuilder/prefab.py,sha256=RJfOv9yzJsySaBz6w4e5ZP8Q7K3LWX6_Buuh2zD9YDQ,24689
-ducktools/classbuilder/prefab.pyi,sha256=eZLjFhM-oHeRBONpCWSb1wLJKGs5Xiq0w_Jeor8Go-w,6525
-ducktools/classbuilder/py.typed,sha256=la67KBlbjXN-_-DfGNcdOcjYumVpKG_Tkw-8n5dnGB4,8
-ducktools_classbuilder-0.10.1.dist-info/licenses/LICENSE,sha256=6Thz9Dbw8R4fWInl6sGl8Rj3UnKnRbDwrc6jZerpugQ,1070
-ducktools_classbuilder-0.10.1.dist-info/METADATA,sha256=LkjNjXyb49v3vYBEvbldkThl9xAgCHhVc8dPNgiMsxw,9231
-ducktools_classbuilder-0.10.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ducktools_classbuilder-0.10.1.dist-info/top_level.txt,sha256=uSDLtio3ZFqdwcsMJ2O5yhjB4Q3ytbBWbA8rJREganc,10
-ducktools_classbuilder-0.10.1.dist-info/RECORD,,