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

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

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

{ducktools_classbuilder-0.6.0 → ducktools_classbuilder-0.6.1}/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.1}/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.1}/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.1"
 
 # Change this name if you make heavy modifications
 INTERNALS_DICT = "__classbuilder_internals__"
@@ -167,7 +167,7 @@ class MethodMaker:
             cls = objtype
 
         local_vars = {}
-        gen = self.code_generator(cls)
+        gen = self.code_generator(cls, self.funcname)
         exec(gen.source_code, gen.globs, local_vars)
         method = local_vars.get(self.funcname)
 
@@ -187,7 +187,7 @@ class MethodMaker:
 
 
 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 +239,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 +265,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 +295,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 +318,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 +334,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 +342,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 +366,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)
 

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

@@ -30,7 +30,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 +46,28 @@ 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_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

{ducktools_classbuilder-0.6.0 → ducktools_classbuilder-0.6.1}/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.1}/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.1}/src/ducktools/classbuilder/prefab.pyi

@@ -7,6 +7,7 @@ from collections.abc import Callable
 from . import (
     NOTHING,
     Field,
+    GeneratedCode,
     MethodMaker,
     SlotMakerMeta,
 )
@@ -27,12 +28,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

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

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

@@ -50,8 +50,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)