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

{ducktools_classbuilder-0.6.1/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.1
+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.1 → 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.1"
+__version__ = "v0.6.2"
 
 # Change this name if you make heavy modifications
 INTERNALS_DICT = "__classbuilder_internals__"
@@ -158,32 +158,69 @@ 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, self.funcname)
+        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):
@@ -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.1 → 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
@@ -49,7 +51,12 @@ class MethodMaker:
     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,
@@ -86,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
@@ -96,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]]: ...
 
 
@@ -126,6 +135,7 @@ class Field(metaclass=SlotMakerMeta):
 
     __slots__: dict[str, str]
     __classbuilder_internals__: dict
+    __signature__: inspect.Signature
 
     def __init__(
         self,
@@ -249,6 +259,7 @@ class GatheredFields:
     modifications: dict[str, typing.Any]
 
     __classbuilder_internals__: dict
+    __signature__: inspect.Signature
 
     def __init__(
         self,

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

@@ -2,6 +2,8 @@ import typing
 from types import MappingProxyType
 from typing_extensions import dataclass_transform
 
+import inspect
+
 from collections.abc import Callable
 
 from . import (
@@ -42,6 +44,7 @@ asdict_maker: MethodMaker
 
 class Attribute(Field):
     __slots__: dict
+    __signature__: inspect.Signature
 
     iter: bool
     serialize: bool

{ducktools_classbuilder-0.6.1 → 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.1
+Version: 0.6.2
 Summary: Toolkit for creating class boilerplate generators
 Author: David C Ellis
 License: MIT License

{ducktools_classbuilder-0.6.1 → 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,
@@ -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.1/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.