ducktools-classbuilder 0.6.0__tar.gz → 0.6.2__tar.gz

{ducktools_classbuilder-0.6.0/src/ducktools_classbuilder.egg-info → ducktools_classbuilder-0.6.2}/PKG-INFO

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

ducktools_classbuilder-0.6.2/docs/approach_vs_tool.md

@@ -0,0 +1,30 @@
+# Approaches and tools #
+
+As this module's code generation is inspired by the workings of [David Beazley's Cluegen](https://github.com/dabeaz/cluegen)
+I thought it was briefly worth discussing his note on learning an approach vs using a tool.
+
+I think that learning an approach is valuable, this module would not exist without the
+example given by `cluegen`.
+
+However, what I found was that in essentially every case where I wanted to use 
+these generating tools, I needed to modify them - often significantly. 
+It quickly became easier to just create my own tool and upload it as a package.
+
+For example, `cluegen` has a few subtle "exercises for the reader". It needs extending
+and fixing for some use-cases.
+   * Default values that are not builtins need to be passed as part of the globals 
+     dict to `exec`.
+   * No support for mutable defaults.
+   * Subclass methods will be overwritten if they call a cluegen method that has not been
+     generated via `super().methodname(...)`
+   * `inspect.signature(cls)` does not work if `cls.__init__` has not already been generated.
+     (I think this is actually a bug in inspect).
+   * Need an extra filter to support things like `ClassVar`.
+
+In the general spirit though, this module intends to provide some basic tools to help 
+create your own customized boilerplate generators.
+The generator included in the base module is intended to be used to help 'bootstrap' a 
+modified generator with features that work how **you** want them to work.
+
+The `prefab` module is the more fully featured tool that handles the additional cases *I*
+needed. 

{ducktools_classbuilder-0.6.0 → ducktools_classbuilder-0.6.2}/docs/extension_examples.md

@@ -79,12 +79,12 @@ from ducktools.classbuilder import (
 )
 
 
-def iter_generator(cls):
+def iter_generator(cls, funcname="__iter__"):
     field_names = get_fields(cls).keys()
     field_yield = "\n".join(f"    yield self.{f}" for f in field_names)
     if not field_yield:
         field_yield = "    yield from ()"
-    code = f"def __iter__(self):\n" f"{field_yield}"
+    code = f"def {funcname}(self):\n" f"{field_yield}"
     globs = {}
     return GeneratedCode(code, globs)
 
@@ -143,7 +143,7 @@ class PosOnlyField(Field):
     __slots__ = SlotFields(pos_only=True)
 
 
-def init_generator(cls):
+def init_generator(cls, funcname="__init__"):
     fields = get_fields(cls)
 
     arglist = []
@@ -177,11 +177,11 @@ def init_generator(cls):
 
     args = ", ".join(arglist)
     assigns = "\n    ".join(assignments)
-    code = f"def __init__(self, {args}):\n" f"    {assigns}\n"
+    code = f"def {funcname}(self, {args}):\n" f"    {assigns}\n"
     return GeneratedCode(code, globs)
 
 
-def repr_generator(cls):
+def repr_generator(cls, funcname="__repr__"):
     fields = get_fields(cls)
     content_list = []
     for name, field in fields.items():
@@ -193,7 +193,7 @@ def repr_generator(cls):
 
     content = ", ".join(content_list)
     code = (
-        f"def __repr__(self):\n"
+        f"def {funcname}(self):\n"
         f"    return f'{{type(self).__qualname__}}({content})'\n"
     )
     globs = {}
@@ -281,7 +281,7 @@ class ConverterField(Field):
     converter = Field(default=None)
 
 
-def setattr_generator(cls):
+def setattr_generator(cls, funcname="__setattr__"):
     fields = get_fields(cls)
     converters = {}
     for k, v in fields.items():
@@ -294,7 +294,7 @@ def setattr_generator(cls):
     }
 
     code = (
-        f"def __setattr__(self, name, value):\n"
+        f"def {funcname}(self, name, value):\n"
         f"    if conv := _converters.get(name):\n"
         f"        _object_setattr(self, name, conv(value))\n"
         f"    else:\n"

{ducktools_classbuilder-0.6.0 → ducktools_classbuilder-0.6.2}/docs/tutorial.md

@@ -120,7 +120,7 @@ field_3: <HIDDEN>
 ```
 
 ```python
-def report_generator(cls):
+def report_generator(cls, funcname="report"):
     fields = dtbuild.get_fields(cls)
 
     field_reports = []
@@ -135,7 +135,7 @@ def report_generator(cls):
 
     code = (
         "@property\n"
-        "def report(self):\n"
+        f"def {funcname}(self):\n"
         f"    return f\"{class_str}\\n{reports_str}\""
     )
     globs = {}

{ducktools_classbuilder-0.6.0 → ducktools_classbuilder-0.6.2}/src/ducktools/classbuilder/__init__.py

@@ -34,7 +34,7 @@ import sys
 
 from .annotations import get_ns_annotations, is_classvar
 
-__version__ = "v0.6.0"
+__version__ = "v0.6.2"
 
 # Change this name if you make heavy modifications
 INTERNALS_DICT = "__classbuilder_internals__"
@@ -158,36 +158,73 @@ class MethodMaker:
     def __repr__(self):
         return f"<MethodMaker for {self.funcname!r} method>"
 
-    def __get__(self, obj, objtype=None):
-        if objtype is None or issubclass(objtype, type):
-            # Called with get(ourclass, type(ourclass))
-            cls = obj
+    def __get__(self, inst, cls):
+        local_vars = {}
+
+        # This can be called via super().funcname(...) in which case the class
+        # may not be the correct one. If this is the correct class
+        # it should have this descriptor in the class dict under
+        # the correct funcname.
+        # Otherwise is should be found in the MRO of the class.
+        if cls.__dict__.get(self.funcname) is self:
+            gen_cls = cls
         else:
-            # Called with get(inst | None, ourclass)
-            cls = objtype
+            for c in cls.__mro__[1:]:  # skip 'cls' as special cased
+                if c.__dict__.get(self.funcname) is self:
+                    gen_cls = c
+                    break
+            else:  # pragma: no cover
+                # This should only be reached if called with incorrect arguments
+                # manually
+                raise AttributeError(
+                    f"Could not find {self!r} in class {cls.__name__!r} MRO."
+                )
 
-        local_vars = {}
-        gen = self.code_generator(cls)
+        gen = self.code_generator(gen_cls, self.funcname)
         exec(gen.source_code, gen.globs, local_vars)
         method = local_vars.get(self.funcname)
 
         try:
-            method.__qualname__ = f"{cls.__qualname__}.{self.funcname}"
+            method.__qualname__ = f"{gen_cls.__qualname__}.{self.funcname}"
         except AttributeError:
             # This might be a property or some other special
             # descriptor. Don't try to rename.
             pass
 
         # Replace this descriptor on the class with the generated function
-        setattr(cls, self.funcname, method)
+        setattr(gen_cls, self.funcname, method)
 
         # Use 'get' to return the generated function as a bound method
         # instead of as a regular function for first usage.
-        return method.__get__(obj, objtype)
+        return method.__get__(inst, cls)
+
+
+class _SignatureMaker:
+    # 'inspect.signature' calls the `__get__` method of the `__init__` methodmaker with
+    # the wrong arguments.
+    # Instead of __get__(None, cls) or __get__(inst, type(inst))
+    # it uses __get__(cls, type(cls)).
+    #
+    # If this is done before `__init__` has been generated then
+    # help(cls) will fail along with inspect.signature(cls)
+    # This signature maker descriptor is placed to override __signature__ and force
+    # the `__init__` signature to be generated first if the signature is requested.
+    def __get__(self, instance, cls):
+        import inspect  # Deferred inspect import
+        _ = cls.__init__  # force generation of `__init__` function
+        # Remove this attribute from the class
+        # This prevents recursion back into this __get__ method.
+        delattr(cls, "__signature__")
+        sig = inspect.signature(cls)
+        setattr(cls, "__signature__", sig)
+        return sig
+
+
+signature_maker = _SignatureMaker()
 
 
 def get_init_generator(null=NOTHING, extra_code=None):
-    def cls_init_maker(cls):
+    def cls_init_maker(cls, funcname="__init__"):
         fields = get_fields(cls)
         flags = get_flags(cls)
 
@@ -239,7 +276,7 @@ def get_init_generator(null=NOTHING, extra_code=None):
 
         assigns = "\n    ".join(assignments) if assignments else "pass\n"
         code = (
-            f"def __init__(self, {args}):\n" 
+            f"def {funcname}(self, {args}):\n" 
             f"    {assigns}\n"
         )
         # Handle additional function calls
@@ -265,7 +302,7 @@ def get_repr_generator(recursion_safe=False, eval_safe=False):
                       not evaluate.
     :return:
     """
-    def cls_repr_generator(cls):
+    def cls_repr_generator(cls, funcname="__repr__"):
         fields = get_fields(cls)
 
         globs = {}
@@ -295,19 +332,19 @@ def get_repr_generator(recursion_safe=False, eval_safe=False):
             if content:
                 code = (
                     f"{recursion_func}"
-                    f"def __repr__(self):\n"
+                    f"def {funcname}(self):\n"
                     f"    return f'<generated class {{type(self).__qualname__}}; {content}>'\n"
                 )
             else:
                 code = (
                     f"{recursion_func}"
-                    f"def __repr__(self):\n"
+                    f"def {funcname}(self):\n"
                     f"    return f'<generated class {{type(self).__qualname__}}>'\n"
                 )
         else:
             code = (
                 f"{recursion_func}"
-                f"def __repr__(self):\n"
+                f"def {funcname}(self):\n"
                 f"    return f'{{type(self).__qualname__}}({content})'\n"
             )
 
@@ -318,7 +355,7 @@ def get_repr_generator(recursion_safe=False, eval_safe=False):
 repr_generator = get_repr_generator()
 
 
-def eq_generator(cls):
+def eq_generator(cls, funcname="__eq__"):
     class_comparison = "self.__class__ is other.__class__"
     field_names = [
         name
@@ -334,7 +371,7 @@ def eq_generator(cls):
         instance_comparison = "True"
 
     code = (
-        f"def __eq__(self, other):\n"
+        f"def {funcname}(self, other):\n"
         f"    return {instance_comparison} if {class_comparison} else NotImplemented\n"
     )
     globs = {}
@@ -342,7 +379,7 @@ def eq_generator(cls):
     return GeneratedCode(code, globs)
 
 
-def frozen_setattr_generator(cls):
+def frozen_setattr_generator(cls, funcname="__setattr__"):
     globs = {}
     field_names = set(get_fields(cls))
     flags = get_flags(cls)
@@ -366,19 +403,19 @@ def frozen_setattr_generator(cls):
         f"    else:\n"
         f"        {setattr_method}\n"
     )
-    code = f"def __setattr__(self, name, value):\n{body}"
+    code = f"def {funcname}(self, name, value):\n{body}"
 
     return GeneratedCode(code, globs)
 
 
-def frozen_delattr_generator(cls):
+def frozen_delattr_generator(cls, funcname="__delattr__"):
     body = (
         '    raise TypeError(\n'
         '        f"{type(self).__name__!r} object "\n'
         '        f"does not support attribute deletion"\n'
         '    )\n'
     )
-    code = f"def __delattr__(self, name):\n{body}"
+    code = f"def {funcname}(self, name):\n{body}"
     globs = {}
     return GeneratedCode(code, globs)
 
@@ -402,7 +439,7 @@ _field_init_maker = MethodMaker(
 )
 
 
-def builder(cls=None, /, *, gatherer, methods, flags=None):
+def builder(cls=None, /, *, gatherer, methods, flags=None, fix_signature=True):
     """
     The main builder for class generation
 
@@ -413,6 +450,10 @@ def builder(cls=None, /, *, gatherer, methods, flags=None):
     :type methods: set[MethodMaker]
     :param flags: additional flags to store in the internals dictionary
                   for use by method generators.
+    :type flags: None | dict[str, bool]
+    :param fix_signature: Add a __signature__ attribute to work-around an issue with
+                          inspect.signature incorrectly handling __init__ descriptors.
+    :type fix_signature: bool
     :return: The modified class (the class itself is modified, but this is expected).
     """
     # Handle `None` to make wrapping with a decorator easier.
@@ -459,6 +500,10 @@ def builder(cls=None, /, *, gatherer, methods, flags=None):
 
     internals["methods"] = _MappingProxyType(internal_methods)
 
+    # Fix for inspect.signature(cls)
+    if fix_signature:
+        setattr(cls, "__signature__", signature_maker)
+
     return cls
 
 

{ducktools_classbuilder-0.6.0 → ducktools_classbuilder-0.6.2}/src/ducktools/classbuilder/__init__.pyi

@@ -1,6 +1,8 @@
 import types
 import typing
 
+import inspect
+
 from collections.abc import Callable
 from types import MappingProxyType
 from typing_extensions import dataclass_transform
@@ -30,7 +32,10 @@ class _KW_ONLY_TYPE:
 
 KW_ONLY: _KW_ONLY_TYPE
 # Stub Only
-_codegen_type = Callable[[type], GeneratedCode]
+@typing.type_check_only
+class _CodegenType(typing.Protocol):
+    def __call__(self, cls: type, funcname: str = ...) -> GeneratedCode: ...
+
 
 class GeneratedCode:
     __slots__: tuple[str, str]
@@ -43,28 +48,33 @@ class GeneratedCode:
 
 class MethodMaker:
     funcname: str
-    code_generator: _codegen_type
-    def __init__(self, funcname: str, code_generator: _codegen_type) -> None: ...
+    code_generator: _CodegenType
+    def __init__(self, funcname: str, code_generator: _CodegenType) -> None: ...
     def __repr__(self) -> str: ...
-    def __get__(self, instance, cls=None) -> Callable: ...
+    def __get__(self, instance, cls) -> Callable: ...
+
+class _SignatureMaker:
+    def __get__(self, instance, cls) -> inspect.Signature: ...
+
+signature_maker: _SignatureMaker
 
 def get_init_generator(
     null: _NothingType = NOTHING,
     extra_code: None | list[str] = None
-) -> Callable[[type], GeneratedCode]: ...
+) -> _CodegenType: ...
 
-def init_generator(cls: type) -> GeneratedCode: ...
+def init_generator(cls: type, funcname: str="__init__") -> GeneratedCode: ...
 
 def get_repr_generator(
     recursion_safe: bool = False,
     eval_safe: bool = False
-) -> Callable[[type], GeneratedCode]: ...
-def repr_generator(cls: type) -> GeneratedCode: ...
-def eq_generator(cls: type) -> GeneratedCode: ...
+) -> _CodegenType: ...
+def repr_generator(cls: type, funcname: str = "__repr__") -> GeneratedCode: ...
+def eq_generator(cls: type, funcname: str = "__eq__") -> GeneratedCode: ...
 
-def frozen_setattr_generator(cls: type) -> GeneratedCode: ...
+def frozen_setattr_generator(cls: type, funcname: str = "__setattr__") -> GeneratedCode: ...
 
-def frozen_delattr_generator(cls: type) -> GeneratedCode: ...
+def frozen_delattr_generator(cls: type, funcname: str = "__delattr__") -> GeneratedCode: ...
 
 init_maker: MethodMaker
 repr_maker: MethodMaker
@@ -83,6 +93,7 @@ def builder(
     gatherer: Callable[[type], tuple[dict[str, Field], dict[str, typing.Any]]],
     methods: frozenset[MethodMaker] | set[MethodMaker],
     flags: dict[str, bool] | None = None,
+    fix_signature: bool = ...,
 ) -> type[_T]: ...
 
 @typing.overload
@@ -93,6 +104,7 @@ def builder(
     gatherer: Callable[[type], tuple[dict[str, Field], dict[str, typing.Any]]],
     methods: frozenset[MethodMaker] | set[MethodMaker],
     flags: dict[str, bool] | None = None,
+    fix_signature: bool = ...,
 ) -> Callable[[type[_T]], type[_T]]: ...
 
 
@@ -123,6 +135,7 @@ class Field(metaclass=SlotMakerMeta):
 
     __slots__: dict[str, str]
     __classbuilder_internals__: dict
+    __signature__: inspect.Signature
 
     def __init__(
         self,
@@ -246,6 +259,7 @@ class GatheredFields:
     modifications: dict[str, typing.Any]
 
     __classbuilder_internals__: dict
+    __signature__: inspect.Signature
 
     def __init__(
         self,

{ducktools_classbuilder-0.6.0 → ducktools_classbuilder-0.6.2}/src/ducktools/classbuilder/annotations.pyi

@@ -4,7 +4,7 @@ import types
 _T = typing.TypeVar("_T")
 _CopiableMappings = dict[str, typing.Any] | types.MappingProxyType[str, typing.Any]
 
-class _StringGlobs:
+class _StringGlobs(dict):
     def __missing__(self, key: _T) -> _T: ...
 
 

{ducktools_classbuilder-0.6.0 → ducktools_classbuilder-0.6.2}/src/ducktools/classbuilder/prefab.py

@@ -60,202 +60,195 @@ def get_attributes(cls):
 
 
 # Method Generators
-def get_init_maker(*, init_name="__init__"):
-    def __init__(cls: type) -> GeneratedCode:
-        globs = {}
-        # Get the internals dictionary and prepare attributes
-        attributes = get_attributes(cls)
-        flags = get_flags(cls)
-
-        kw_only = flags.get("kw_only", False)
-
-        # Handle pre/post init first - post_init can change types for __init__
-        # Get pre and post init arguments
-        pre_init_args = []
-        post_init_args = []
-        post_init_annotations = {}
-
-        for func_name, func_arglist in [
-            (PRE_INIT_FUNC, pre_init_args),
-            (POST_INIT_FUNC, post_init_args),
-        ]:
-            try:
-                func = getattr(cls, func_name)
-                func_code = func.__code__
-            except AttributeError:
-                pass
-            else:
-                argcount = func_code.co_argcount + func_code.co_kwonlyargcount
+def init_generator(cls, funcname="__init__"):
+    globs = {}
+    # Get the internals dictionary and prepare attributes
+    attributes = get_attributes(cls)
+    flags = get_flags(cls)
 
-                # Identify if method is static, if so include first arg, otherwise skip
-                is_static = type(cls.__dict__.get(func_name)) is staticmethod
+    kw_only = flags.get("kw_only", False)
 
-                arglist = (
-                    func_code.co_varnames[:argcount]
-                    if is_static
-                    else func_code.co_varnames[1:argcount]
-                )
+    # Handle pre/post init first - post_init can change types for __init__
+    # Get pre and post init arguments
+    pre_init_args = []
+    post_init_args = []
+    post_init_annotations = {}
+
+    for extra_funcname, func_arglist in [
+        (PRE_INIT_FUNC, pre_init_args),
+        (POST_INIT_FUNC, post_init_args),
+    ]:
+        try:
+            func = getattr(cls, extra_funcname)
+            func_code = func.__code__
+        except AttributeError:
+            pass
+        else:
+            argcount = func_code.co_argcount + func_code.co_kwonlyargcount
 
-                func_arglist.extend(arglist)
-
-                if func_name == POST_INIT_FUNC:
-                    post_init_annotations.update(func.__annotations__)
-
-        pos_arglist = []
-        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 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}"
-                    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"
-                        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
+            # Identify if method is static, if so include first arg, otherwise skip
+            is_static = type(cls.__dict__.get(extra_funcname)) is staticmethod
+
+            arglist = (
+                func_code.co_varnames[:argcount]
+                if is_static
+                else func_code.co_varnames[1:argcount]
+            )
+
+            func_arglist.extend(arglist)
+
+            if extra_funcname == POST_INIT_FUNC:
+                post_init_annotations.update(func.__annotations__)
+
+    pos_arglist = []
+    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 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}=None"
+                        arg = f"{name}={attrib.default!r}"
                     else:
-                        arg = f"{name}: _{name}_type = None"
-                    globs[f"_{name}_factory"] = attrib.default_factory
+                        arg = f"{name}: _{name}_type = {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 = name
+                        arg = f"{name}=_{name}_default"
                     else:
-                        arg = f"{name}: _{name}_type"
-                if attrib.kw_only or kw_only:
-                    kw_only_arglist.append(arg)
-                else:
-                    pos_arglist.append(arg)
-            # Not in init, but need to set defaults
-            else:
-                if attrib.default is not NOTHING:
+                        arg = f"{name}: _{name}_type = _{name}_default"
                     globs[f"_{name}_default"] = attrib.default
-                elif attrib.default_factory is not NOTHING:
-                    globs[f"_{name}_factory"] = attrib.default_factory
-
-        pos_args = ", ".join(pos_arglist)
-        kw_args = ", ".join(kw_only_arglist)
-        if pos_args and kw_args:
-            args = f"{pos_args}, *, {kw_args}"
-        elif kw_args:
-            args = f"*, {kw_args}"
-        else:
-            args = pos_args
-
-        assignments = []
-        processes = []  # post_init values still need default factories to be called.
-        for name, attrib in attributes.items():
-            if attrib.init:
-                if attrib.default_factory is not NOTHING:
-                    value = f"{name} if {name} is not None else _{name}_factory()"
+            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:
-                    value = name
+                    arg = f"{name}: _{name}_type = None"
+                globs[f"_{name}_factory"] = attrib.default_factory
             else:
-                if attrib.default_factory is not NOTHING:
-                    value = f"_{name}_factory()"
-                elif attrib.default is not NOTHING:
-                    value = f"_{name}_default"
+                if attrib.type is NOTHING:
+                    arg = name
                 else:
-                    value = None
-
-            if name in post_init_args:
-                if attrib.default_factory is not NOTHING:
-                    processes.append((name, value))
-            elif value is not None:
-                assignments.append((name, value))
-
-        if hasattr(cls, PRE_INIT_FUNC):
-            pre_init_arg_call = ", ".join(f"{name}={name}" for name in pre_init_args)
-            pre_init_call = f"    self.{PRE_INIT_FUNC}({pre_init_arg_call})\n"
+                    arg = f"{name}: _{name}_type"
+            if attrib.kw_only or kw_only:
+                kw_only_arglist.append(arg)
+            else:
+                pos_arglist.append(arg)
+        # Not in init, but need to set defaults
         else:
-            pre_init_call = ""
-
-        if assignments or processes:
-            body = ""
-            body += "\n".join(
-                f"    self.{name} = {value}" for name, value in assignments
-            )
-            body += "\n"
-            body += "\n".join(f"    {name} = {value}" for name, value in processes)
+            if attrib.default is not NOTHING:
+                globs[f"_{name}_default"] = attrib.default
+            elif attrib.default_factory is not NOTHING:
+                globs[f"_{name}_factory"] = attrib.default_factory
+
+    pos_args = ", ".join(pos_arglist)
+    kw_args = ", ".join(kw_only_arglist)
+    if pos_args and kw_args:
+        args = f"{pos_args}, *, {kw_args}"
+    elif kw_args:
+        args = f"*, {kw_args}"
+    else:
+        args = pos_args
+
+    assignments = []
+    processes = []  # post_init values still need default factories to be called.
+    for name, attrib in attributes.items():
+        if attrib.init:
+            if attrib.default_factory is not NOTHING:
+                value = f"{name} if {name} is not None else _{name}_factory()"
+            else:
+                value = name
         else:
-            body = "    pass"
+            if attrib.default_factory is not NOTHING:
+                value = f"_{name}_factory()"
+            elif attrib.default is not NOTHING:
+                value = f"_{name}_default"
+            else:
+                value = None
 
-        if hasattr(cls, POST_INIT_FUNC):
-            post_init_arg_call = ", ".join(f"{name}={name}" for name in post_init_args)
-            post_init_call = f"    self.{POST_INIT_FUNC}({post_init_arg_call})\n"
-        else:
-            post_init_call = ""
+        if name in post_init_args:
+            if attrib.default_factory is not NOTHING:
+                processes.append((name, value))
+        elif value is not None:
+            assignments.append((name, value))
+
+    if hasattr(cls, PRE_INIT_FUNC):
+        pre_init_arg_call = ", ".join(f"{name}={name}" for name in pre_init_args)
+        pre_init_call = f"    self.{PRE_INIT_FUNC}({pre_init_arg_call})\n"
+    else:
+        pre_init_call = ""
 
-        code = (
-            f"def {init_name}(self, {args}):\n"
-            f"{pre_init_call}\n"
-            f"{body}\n"
-            f"{post_init_call}\n"
+    if assignments or processes:
+        body = ""
+        body += "\n".join(
+            f"    self.{name} = {value}" for name, value in assignments
         )
-        return GeneratedCode(code, globs)
+        body += "\n"
+        body += "\n".join(f"    {name} = {value}" for name, value in processes)
+    else:
+        body = "    pass"
 
-    return MethodMaker(init_name, __init__)
+    if hasattr(cls, POST_INIT_FUNC):
+        post_init_arg_call = ", ".join(f"{name}={name}" for name in post_init_args)
+        post_init_call = f"    self.{POST_INIT_FUNC}({post_init_arg_call})\n"
+    else:
+        post_init_call = ""
+
+    code = (
+        f"def {funcname}(self, {args}):\n"
+        f"{pre_init_call}\n"
+        f"{body}\n"
+        f"{post_init_call}\n"
+        )
 
+    return GeneratedCode(code, globs)
 
-def get_iter_maker():
-    def __iter__(cls: type) -> GeneratedCode:
-        fields = get_attributes(cls)
 
-        valid_fields = (
-            name for name, attrib in fields.items()
-            if attrib.iter
-        )
+def iter_generator(cls, funcname="__iter__"):
+    fields = get_attributes(cls)
 
-        values = "\n".join(f"    yield self.{name}" for name in valid_fields)
+    valid_fields = (
+        name for name, attrib in fields.items()
+        if attrib.iter
+    )
 
-        # if values is an empty string
-        if not values:
-            values = "    yield from ()"
+    values = "\n".join(f"    yield self.{name}" for name in valid_fields)
 
-        code = f"def __iter__(self):\n{values}"
-        globs = {}
-        return GeneratedCode(code, globs)
+    # if values is an empty string
+    if not values:
+        values = "    yield from ()"
 
-    return MethodMaker("__iter__", __iter__)
+    code = f"def {funcname}(self):\n{values}"
+    globs = {}
+    return GeneratedCode(code, globs)
 
 
-def get_asdict_maker():
-    def as_dict_gen(cls: type) -> GeneratedCode:
-        fields = get_attributes(cls)
+def as_dict_generator(cls, funcname="as_dict"):
+    fields = get_attributes(cls)
 
-        vals = ", ".join(
-            f"'{name}': self.{name}"
-            for name, attrib in fields.items()
-            if attrib.serialize
-        )
-        out_dict = f"{{{vals}}}"
-        code = f"def as_dict(self): return {out_dict}"
+    vals = ", ".join(
+        f"'{name}': self.{name}"
+        for name, attrib in fields.items()
+        if attrib.serialize
+    )
+    out_dict = f"{{{vals}}}"
+    code = f"def {funcname}(self): return {out_dict}"
 
-        globs = {}
-        return GeneratedCode(code, globs)
-    return MethodMaker("as_dict", as_dict_gen)
+    globs = {}
+    return GeneratedCode(code, globs)
 
 
-init_maker = get_init_maker()
-prefab_init_maker = get_init_maker(init_name=PREFAB_INIT_FUNC)
+init_maker = MethodMaker("__init__", init_generator)
+prefab_init_maker = MethodMaker(PREFAB_INIT_FUNC, init_generator)
 repr_maker = MethodMaker(
     "__repr__",
     get_repr_generator(recursion_safe=False, eval_safe=True)
@@ -264,8 +257,8 @@ recursive_repr_maker = MethodMaker(
     "__repr__",
     get_repr_generator(recursion_safe=True, eval_safe=True)
 )
-iter_maker = get_iter_maker()
-asdict_maker = get_asdict_maker()
+iter_maker = MethodMaker("__iter__", iter_generator)
+asdict_maker = MethodMaker("as_dict", as_dict_generator)
 
 
 # Updated field with additional attributes

{ducktools_classbuilder-0.6.0 → ducktools_classbuilder-0.6.2}/src/ducktools/classbuilder/prefab.pyi

@@ -2,11 +2,14 @@ import typing
 from types import MappingProxyType
 from typing_extensions import dataclass_transform
 
+import inspect
+
 from collections.abc import Callable
 
 from . import (
     NOTHING,
     Field,
+    GeneratedCode,
     MethodMaker,
     SlotMakerMeta,
 )
@@ -27,12 +30,9 @@ class PrefabError(Exception): ...
 
 def get_attributes(cls: type) -> dict[str, Attribute]: ...
 
-def get_init_maker(*, init_name: str="__init__") -> MethodMaker: ...
-
-def get_iter_maker() -> MethodMaker: ...
-
-def get_asdict_maker() -> MethodMaker: ...
-
+def init_generator(cls: type, funcname: str = "__init__") -> GeneratedCode: ...
+def iter_generator(cls: type, funcname: str = "__iter__") -> GeneratedCode: ...
+def as_dict_generator(cls: type, funcname: str = "as_dict") -> GeneratedCode: ...
 
 init_maker: MethodMaker
 prefab_init_maker: MethodMaker
@@ -44,6 +44,7 @@ asdict_maker: MethodMaker
 
 class Attribute(Field):
     __slots__: dict
+    __signature__: inspect.Signature
 
     iter: bool
     serialize: bool

{ducktools_classbuilder-0.6.0 → ducktools_classbuilder-0.6.2/src/ducktools_classbuilder.egg-info}/PKG-INFO

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

{ducktools_classbuilder-0.6.0 → ducktools_classbuilder-0.6.2}/tests/test_core.py

@@ -8,6 +8,7 @@ from ducktools.classbuilder import (
 
     builder,
     default_methods,
+    eq_maker,
     get_fields,
     get_flags,
     get_methods,
@@ -50,8 +51,8 @@ def test_get_fields_flags_methods():
 
 
 def test_method_maker():
-    def generator(cls):
-        code = "def demo(self): return self.x"
+    def generator(cls, funcname="demo"):
+        code = f"def {funcname}(self): return self.x"
         globs = {}
         return GeneratedCode(code, globs)
 
@@ -527,3 +528,33 @@ def test_signature():
         __slots__ = SlotFields(x=42)
 
     assert str(inspect.signature(SigClass)) == "(x=42)"
+
+
+def test_subclass_method_not_overwritten():
+    @slotclass
+    class X:
+        __slots__ = SlotFields(x=Field())
+
+    class Y(X):
+        def __init__(self, x, y):
+            self.y = y
+            super().__init__(x=x)
+
+    y_init_func = Y.__init__
+
+    assert X.__dict__["__eq__"] is eq_maker
+
+    y_inst = Y(0, 1)
+
+    # super().__init__ method generated correctly
+    assert y_init_func is Y.__init__
+    assert X.__dict__["__init__"] is not init_maker
+    assert (y_inst.x, y_inst.y) == (0, 1)
+
+    # Would fail previously as __init__ would be overwritten
+    y_inst_2 = Y(0, 2)
+
+    assert y_inst == y_inst_2
+
+    assert X.__dict__["__eq__"] is not eq_maker
+    assert "__eq__" not in Y.__dict__

ducktools_classbuilder-0.6.0/docs/approach_vs_tool.md

@@ -1,16 +0,0 @@
-# Approaches and tools #
-
-As this module's code generation is inspired by the workings of [David Beazley's Cluegen](https://github.com/dabeaz/cluegen)
-I thought it was briefly worth discussing his note on learning an approach vs using a tool.
-
-I think that learning an approach is valuable, this module would not exist without the
-example given by `cluegen`. It also wouldn't exist if I hadn't needed to extend `cluegen`
-for some basic features (try using `Path` default values with `cluegen`).
-
-In the general spirit though, this module intends to provide some basic tools to help 
-build your own custom class generators.
-The generator included in the base module is intended to be used to help 'bootstrap' a 
-modified generator with features that work how **you** want them to work.
-
-The `prefab` module is the more fully featured powertool *I* built with these tools. 
-However, much like a prefabricated building, it may not be what you desire.