ducktools-classbuilder 0.8.0__tar.gz → 0.8.1__tar.gz

{ducktools_classbuilder-0.8.0 → ducktools_classbuilder-0.8.1}/MANIFEST.in

@@ -5,5 +5,6 @@ graft docs
 prune */build
 prune */dist
 prune */.pytest_cache
+prune perf
 
 global-exclude *~ *.py[cod] *.so

{ducktools_classbuilder-0.8.0 → ducktools_classbuilder-0.8.1}/PKG-INFO

@@ -1,30 +1,8 @@
 Metadata-Version: 2.1
 Name: ducktools-classbuilder
-Version: 0.8.0
+Version: 0.8.1
 Summary: Toolkit for creating class boilerplate generators
 Author: David C Ellis
-License: 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.
-        
 Project-URL: Homepage, https://github.com/davidcellis/ducktools-classbuilder
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python :: 3.8
@@ -37,7 +15,7 @@ Classifier: Operating System :: OS Independent
 Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-License-File: LICENSE.md
+License-File: LICENSE
 Provides-Extra: testing
 Requires-Dist: pytest>=8.2; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"

{ducktools_classbuilder-0.8.0 → ducktools_classbuilder-0.8.1}/docs/index.md

@@ -77,11 +77,11 @@ is created.
 
 ```python
 from ducktools.classbuilder import (
-    SlotMakerMeta, 
-    annotation_gatherer,
+    SlotMakerMeta,
     builder,
     check_argument_order,
     default_methods,
+    unified_gatherer,
 )
 
 
@@ -91,7 +91,7 @@ class AnnotationClass(metaclass=SlotMakerMeta):
     def __init_subclass__(
             cls,
             methods=default_methods,
-            gatherer=annotation_gatherer,
+            gatherer=unified_gatherer,
             **kwargs
     ):
         # Check class dict otherwise this will always be True as this base
@@ -103,12 +103,11 @@ class AnnotationClass(metaclass=SlotMakerMeta):
         super().__init_subclass__(**kwargs)
 
 
-
 class AnnotatedDC(AnnotationClass):
     the_answer: int = 42
     the_question: str = "What do you get if you multiply six by nine?"
 
-    
+
 ex = AnnotatedDC()
 print(ex)
 ```

{ducktools_classbuilder-0.8.0 → ducktools_classbuilder-0.8.1}/pyproject.toml

@@ -25,7 +25,6 @@ classifiers = [
     "License :: OSI Approved :: MIT License",
 ]
 dynamic = ['version']
-license = {file = "LICENSE.md"}
 
 [project.optional-dependencies]
 testing = ["pytest>=8.2", "pytest-cov", "typing_extensions"]

ducktools_classbuilder-0.8.1/src/ducktools/classbuilder/_version.py

@@ -0,0 +1,2 @@
+__version__ = "0.8.1"
+__version_tuple__ = (0, 8, 1)

{ducktools_classbuilder-0.8.0 → ducktools_classbuilder-0.8.1}/src/ducktools_classbuilder.egg-info/PKG-INFO

@@ -1,30 +1,8 @@
 Metadata-Version: 2.1
 Name: ducktools-classbuilder
-Version: 0.8.0
+Version: 0.8.1
 Summary: Toolkit for creating class boilerplate generators
 Author: David C Ellis
-License: 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.
-        
 Project-URL: Homepage, https://github.com/davidcellis/ducktools-classbuilder
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python :: 3.8
@@ -37,7 +15,7 @@ Classifier: Operating System :: OS Independent
 Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-License-File: LICENSE.md
+License-File: LICENSE
 Provides-Extra: testing
 Requires-Dist: pytest>=8.2; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"

{ducktools_classbuilder-0.8.0 → ducktools_classbuilder-0.8.1}/src/ducktools_classbuilder.egg-info/SOURCES.txt

@@ -1,6 +1,6 @@
 .gitignore
 .readthedocs.yaml
-LICENSE.md
+LICENSE
 MANIFEST.in
 README.md
 pyproject.toml
@@ -29,10 +29,6 @@ docs_code/docs_ex8_converters.py
 docs_code/docs_ex9_annotated.py
 docs_code/index_example.py
 docs_code/tutorial_code.py
-perf/cluegen.py
-perf/dataklasses.py
-perf/hyperfine_testmaker.py
-perf/perf_profile.py
 src/ducktools/classbuilder/__init__.py
 src/ducktools/classbuilder/__init__.pyi
 src/ducktools/classbuilder/_version.py

ducktools_classbuilder-0.8.0/perf/cluegen.py

@@ -1,127 +0,0 @@
-# cluegen.py
-#
-# Classes generated from type clues.
-#
-#     https://github.com/dabeaz/cluegen
-#
-# Author: David Beazley (@dabeaz).
-#         http://www.dabeaz.com
-#
-# Copyright (C) 2018-2021.
-#
-# Permission is granted to use, copy, and modify this code in any
-# manner as long as this copyright message and disclaimer remain in
-# the source code.  There is no warranty.  Try to use the code for the
-# greater good.
-
-import types
-
-
-# Collect all type clues from a class and base classes.
-def all_clues(cls):
-    clues = {}
-    for c in reversed(cls.__mro__):
-        clues.update(getattr(c, '__annotations__', {}))
-    return clues
-
-
-# Decorator to define methods of a class as a code generator.
-def cluegen(func):
-    def __get__(self, instance, cls):
-        locs = {}
-        code = func(cls)
-        exec(code, locs)
-        meth = locs[func.__name__]
-        setattr(cls, func.__name__, meth)
-        return meth.__get__(instance, cls)
-
-    def __set_name__(self, cls, name):
-        methods = cls.__dict__.get('_methods', list(cls._methods))
-        if '_methods' not in cls.__dict__:
-            cls._methods = methods
-        cls._methods.append((name, self))
-
-    return type(f'ClueGen_{func.__name__}', (), dict(__get__=__get__,
-                                                     __set_name__=__set_name__))()
-
-
-# Base class for defining data structures
-class DatumBase:
-    __slots__ = ()
-    _methods = []
-
-    @classmethod
-    def __init_subclass__(cls):
-        submethods = []
-        for name, val in cls._methods:
-            if name not in cls.__dict__:
-                setattr(cls, name, val)
-                submethods.append((name, val))
-            elif val is cls.__dict__[name]:
-                submethods.append((name, val))
-
-        if submethods != cls._methods:
-            cls._methods = submethods
-
-
-class Datum(DatumBase):
-    __slots__ = ()
-
-    @classmethod
-    def __init_subclass__(cls):
-        super().__init_subclass__()
-        cls.__match_args__ = tuple(all_clues(cls))
-
-    @cluegen
-    def __init__(cls):
-        clues = all_clues(cls)
-        args = ', '.join(f'{name}={getattr(cls, name)!r}'
-                         if hasattr(cls, name) and not isinstance(getattr(cls, name),
-                                                                  types.MemberDescriptorType) else name
-                         for name in clues)
-        body = '\n'.join(f'   self.{name} = {name}'
-                         for name in clues)
-        return f'def __init__(self, {args}):\n{body}\n'
-
-    @cluegen
-    def __repr__(cls):
-        clues = all_clues(cls)
-        fmt = ', '.join('%s={self.%s!r}' % (name, name) for name in clues)
-        return 'def __repr__(self):\n' \
-               '    return f"{type(self).__name__}(%s)"' % fmt
-
-    @cluegen
-    def __iter__(cls):
-        clues = all_clues(cls)
-        values = '\n'.join(f'   yield self.{name}' for name in clues)
-        return 'def __iter__(self):\n' + values
-
-    @cluegen
-    def __eq__(cls):
-        clues = all_clues(cls)
-        selfvals = ','.join(f'self.{name}' for name in clues)
-        othervals = ','.join(f'other.{name}' for name in clues)
-        return 'def __eq__(self, other):\n' \
-               '    if self.__class__ is other.__class__:\n' \
-               f'        return ({selfvals},) == ({othervals},)\n' \
-               '    else:\n' \
-               '        return NotImplemented\n'
-
-    @cluegen
-    def __hash__(cls):
-        clues = all_clues(cls)
-        if clues:
-            self_tuple = '(' + ','.join(f'self.{name}' for name in clues) + ',)'
-        else:
-            self_tuple = '()'
-        return 'def __hash__(self):\n' \
-               f'    return hash({self_tuple})\n'
-
-
-# Example use
-if __name__ == '__main__':
-    # Start defining classes
-    class Coordinates(Datum):
-        x: int
-        y: int
-

ducktools_classbuilder-0.8.0/perf/dataklasses.py

@@ -1,102 +0,0 @@
-# dataklasses.py
-#
-#     https://github.com/dabeaz/dataklasses
-#
-# Author: David Beazley (@dabeaz).
-#         http://www.dabeaz.com
-#
-# Copyright (C) 2021-2022.
-#
-# Permission is granted to use, copy, and modify this code in any
-# manner as long as this copyright message and disclaimer remain in
-# the source code.  There is no warranty.  Try to use the code for the
-# greater good.
-
-__all__ = ['dataklass']
-
-from functools import lru_cache, reduce
-
-
-def codegen(func):
-    @lru_cache
-    def make_func_code(numfields):
-        names = [f'_{n}' for n in range(numfields)]
-        exec(func(names), globals(), d := {})
-        return d.popitem()[1]
-
-    return make_func_code
-
-
-def patch_args_and_attributes(func, fields, start=0):
-    return type(func)(func.__code__.replace(
-        co_names=(*func.__code__.co_names[:start], *fields),
-        co_varnames=('self', *fields),
-    ), func.__globals__)
-
-
-def patch_attributes(func, fields, start=0):
-    return type(func)(func.__code__.replace(
-        co_names=(*func.__code__.co_names[:start], *fields)
-    ), func.__globals__)
-
-
-def all_hints(cls):
-    return reduce(lambda x, y: getattr(y, '__annotations__', {}) | x, cls.__mro__, {})
-
-
-@codegen
-def make__init__(fields):
-    code = 'def __init__(self, ' + ','.join(fields) + '):\n'
-    return code + '\n'.join(f' self.{name} = {name}\n' for name in fields)
-
-
-@codegen
-def make__repr__(fields):
-    return 'def __repr__(self):\n' \
-           ' return f"{type(self).__name__}(' + \
-           ', '.join('{self.' + name + '!r}' for name in fields) + ')"\n'
-
-
-@codegen
-def make__eq__(fields):
-    selfvals = ','.join(f'self.{name}' for name in fields)
-    othervals = ','.join(f'other.{name}' for name in fields)
-    return 'def __eq__(self, other):\n' \
-           '  if self.__class__ is other.__class__:\n' \
-           f'    return ({selfvals},) == ({othervals},)\n' \
-           '  else:\n' \
-           '    return NotImplemented\n'
-
-
-@codegen
-def make__iter__(fields):
-    return 'def __iter__(self):\n' + '\n'.join(f'   yield self.{name}' for name in fields)
-
-
-@codegen
-def make__hash__(fields):
-    self_tuple = '(' + ','.join(f'self.{name}' for name in fields) + ',)'
-    return 'def __hash__(self):\n' \
-           f'    return hash({self_tuple})\n'
-
-
-def dataklass(cls):
-    fields = all_hints(cls)
-    nfields = len(fields)
-    clsdict = vars(cls)
-    if not '__init__' in clsdict: cls.__init__ = patch_args_and_attributes(make__init__(nfields), fields)
-    if not '__repr__' in clsdict: cls.__repr__ = patch_attributes(make__repr__(nfields), fields, 2)
-    if not '__eq__' in clsdict: cls.__eq__ = patch_attributes(make__eq__(nfields), fields, 1)
-    # if not '__iter__' in clsdict:  cls.__iter__ = patch_attributes(make__iter__(nfields), fields)
-    # if not '__hash__' in clsdict:  cls.__hash__ = patch_attributes(make__hash__(nfields), fields, 1)
-    cls.__match_args__ = tuple(fields)
-    return cls
-
-
-# Example use
-if __name__ == '__main__':
-    @dataklass
-    class Coordinates:
-        x: int
-        y: int
-

ducktools_classbuilder-0.8.0/perf/hyperfine_testmaker.py

@@ -1,311 +0,0 @@
-"""
-This script makes all of the hyperfine tests used in this project
-"""
-import sys
-from pathlib import Path
-from ducktools.classbuilder.prefab import prefab
-
-base_dir = Path(__file__).parent / 'hyperfine_testfiles'
-importer_dir = base_dir / 'hyperfine_importers'
-classdef_dir = importer_dir / 'class_definitions'
-results_dir = base_dir / 'hyperfine_results'
-
-# Template Body Files #
-
-standard_template = '''
-class C{n}:
-    def __init__(self, a, b, c, d, e):
-        self.a = a
-        self.b = b
-        self.c = c
-        self.d = d
-        self.e = e
-
-    def __repr__(self):
-        return f'C{n}({{self.a!r}}, {{self.b!r}}, {{self.c!r}}, {{self.d!r}}, {{self.e!r}})'
-
-    def __eq__(self, other):
-        if self.__class__ is other.__class__:
-            return (self.a, self.b, self.c, self.d, self.e) == (other.a, other.b, other.c, other.d, other.e)
-        else:
-            return NotImplemented
-
-'''
-
-namedtuple_template = '''
-C{n} = namedtuple('C{n}', ['a', 'b', 'c', 'd', 'e'])
-'''
-
-NamedTuple_template = '''
-class C{n}(NamedTuple):
-    a : int
-    b : int
-    c : int
-    d : int
-    e : int
-'''
-
-dataclass_template = '''
-@dataclass
-class C{n}:
-    a: int
-    b: int
-    c: int
-    d: int
-    e: int
-'''
-
-attr_noslots_template = '''
-@define(slots=False)
-class C{n}:
-    a: int
-    b: int
-    c: int
-    d: int
-    e: int
-'''
-
-attr_slots_template = '''
-@define(slots=True)
-class C{n}:
-    a: int
-    b: int
-    c: int
-    d: int
-    e: int
-'''
-
-pydantic_template = '''
-class C{n}(BaseModel):
-    a: int
-    b: int
-    c: int
-    d: int
-    e: int
-'''
-
-cluegen_template = '''
-class C{n}(Datum):
-    a: int
-    b: int
-    c: int
-    d: int
-    e: int
-'''
-
-# cluegen, but same default methods as dataclasses generated
-cluegen_eval_template = '''
-class C{n}(Datum):
-    a: int
-    b: int
-    c: int
-    d: int
-    e: int
-
-C{n}.__init__, C{n}.__repr__, C{n}.__eq__
-'''
-
-dataklass_template = '''
-@dataklass
-class C{n}:
-    a: int
-    b: int
-    c: int
-    d: int
-    e: int
-'''
-
-dataklass_eval_template = '''
-@dataklass
-class C{n}:
-    a: int
-    b: int
-    c: int
-    d: int
-    e: int
-
-C{n}.__init__, C{n}.__repr__, C{n}.__eq__
-'''
-
-slotclass_template = '''
-@slotclass
-class C{n}:
-    __slots__ = SlotFields(
-        a=Field(),
-        b=Field(),
-        c=Field(),
-        d=Field(),
-        e=Field(),
-    )
-'''
-
-prefab_template = '''
-@prefab
-class C{n}:
-    a: int
-    b: int
-    c: int
-    d: int
-    e: int
-'''
-
-prefab_attribute_template = '''
-@prefab
-class C{n}:
-    a = attribute()
-    b = attribute()
-    c = attribute()
-    d = attribute()
-    e = attribute()
-'''
-
-prefab_slots_template = '''
-@prefab
-class C{n}:
-    __slots__ = SlotFields(
-        a=attribute(),
-        b=attribute(),
-        c=attribute(),
-        d=attribute(),
-        e=attribute(),
-    )
-'''
-
-prefab_eval_template = '''
-@prefab
-class C{n}:
-    a: int
-    b: int
-    c: int
-    d: int
-    e: int
-
-C{n}.__init__, C{n}.__repr__, C{n}.__eq__
-'''
-
-
-# Import Headings #
-
-namedtuple_header = "from collections import namedtuple"
-NamedTuple_header = "from typing import NamedTuple"
-dataclass_header = "from dataclasses import dataclass"
-attr_header = "from attrs import define"
-pydantic_header = "from pydantic import BaseModel"
-cluegen_header = "from cluegen import Datum"
-dataklass_header = "from dataklasses import dataklass"
-slotclass_header = "from ducktools.classbuilder import slotclass, SlotFields, Field"
-prefab_header = "from ducktools.classbuilder.prefab import prefab, attribute, SlotFields"
-
-
-def write_perf_file(outpath, count, template, setup):
-    with open(outpath, 'w') as f:
-        f.write(setup)
-        for n in range(count):
-            f.write(template.format(n=n))
-
-
-@prefab
-class TestData:
-    import_name: str
-    import_header: str
-    class_template: str
-
-    @property
-    def importer_file(self):
-        importer_name = f"{self.import_name}_timer.py"
-        return importer_dir / importer_name
-
-    @property
-    def def_file(self):
-        def_name = f"{self.import_name}_data.py"
-        return classdef_dir / def_name
-
-    def write_perf_importer(self):
-        data = f"import class_definitions.{self.import_name}_data\n"
-        self.importer_file.write_text(data)
-
-    def write_classdef_file(self, count=100):
-        with self.def_file.open(mode='w') as f:
-            f.write(self.import_header)
-            for n in range(count):
-                f.write(self.class_template.format(n=n))
-
-
-datasets = [
-    TestData('native_classes', '', standard_template),
-    TestData('slotclasses', slotclass_header, slotclass_template),
-    TestData('prefab', prefab_header, prefab_template),
-    TestData('prefab_slots', prefab_header, prefab_slots_template),
-    TestData('prefab_eval', prefab_header, prefab_eval_template),
-    TestData('namedtuples', namedtuple_header, namedtuple_template),
-    TestData('typed_namedtuples', NamedTuple_header, NamedTuple_template),
-    TestData('dataclasses', dataclass_header, dataclass_template),
-    TestData('attrs_noslots', attr_header, attr_noslots_template),
-    TestData('attrs_slots', attr_header, attr_slots_template),
-    TestData('pydantic', pydantic_header, pydantic_template),
-    # TestData('cluegen', cluegen_header, cluegen_template),
-    # TestData('cluegen_eval', cluegen_header, cluegen_eval_template),
-]
-
-
-def write_tests(*, runs=100, warmup=20, includes_pass=True):
-    base_dir.mkdir(exist_ok=True)
-    importer_dir.mkdir(exist_ok=True)
-    classdef_dir.mkdir(exist_ok=True)
-    results_dir.mkdir(exist_ok=True)
-
-    script_ext = "bat" if sys.platform == "win32" else "sh"
-
-    for data in datasets:
-        data.write_perf_importer()
-        data.write_classdef_file(count=100)
-
-    tests = " ".join(
-        f'"python hyperfine_importers/{data.import_name}_timer.py"'
-        for data in datasets
-    )
-
-    versions = (
-        "import attrs, pydantic, ducktools.classbuilder;"
-        "print(f'attrs {attrs.__version__}');"
-        "print(f'pydantic {pydantic.__version__}');"
-        "print(f'ducktools-classbuilder {ducktools.classbuilder.__version__}\\n')"
-    )
-
-    if includes_pass:
-        tests = f'"python -c \\"pass\\"" {tests}'
-
-    outpath = results_dir / 'hyperfine_result.md'
-
-    zsh_script = (
-        "python -VV\n"
-        f"python -c \"{versions}\"\n"
-        f"hyperfine --export-markdown {outpath} --shell=none --runs {runs} --warmup {warmup} {tests}"
-    )
-
-    shell_pth = base_dir / f"hyperfine_runner.{script_ext}"
-    shell_pth.write_text(zsh_script)
-
-    outpath = results_dir / 'hyperfine_importtimes.md'
-
-    tests = (
-        '''"python -c \\"pass\\"" '''
-        '''"python -c \\"from ducktools.classbuilder import slotclass\\"" '''
-        '''"python -c \\"from ducktools.classbuilder.prefab import prefab\\"" '''
-        '''"python -c \\"from collections import namedtuple\\"" '''
-        '''"python -c \\"from typing import NamedTuple\\"" '''
-        '''"python -c \\"from dataclasses import dataclass\\"" '''
-        '''"python -c \\"from attrs import define\\"" '''
-        '''"python -c \\"from pydantic import BaseModel\\"" '''
-    )
-
-    import_script = (
-        f"hyperfine --export-markdown {outpath} --shell=none --runs {runs} --warmup {warmup} {tests}"
-    )
-
-    shell_pth = base_dir / f'hyperfine_importtimes.{script_ext}'
-    shell_pth.write_text(import_script)
-
-
-if __name__ == '__main__':
-    write_tests(includes_pass=True, runs=30, warmup=10)