ducktools-classbuilder 0.6.3__tar.gz → 0.7.1__tar.gz

ducktools_classbuilder-0.7.1/.github/dependabot.yml

@@ -0,0 +1,7 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      # Check for updates to GitHub Actions every week
+      interval: "weekly"

ducktools_classbuilder-0.7.1/.github/workflows/auto_test.yml

@@ -0,0 +1,48 @@
+name: UnitTests
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  test-prefab:
+
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest]
+        python-version: ["3.13-dev", "3.12", "3.11", "3.10", "pypy-3.10", "3.9", "3.8"]
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install -e .[testing]
+    - name: Test with pytest
+      run: |
+        pytest tests/ --cov=src/ --cov-report=term-missing
+
+  test-stubs:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python 3.8
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.8"
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install -e .[testing]
+      - name: Check type stub files
+        run: |
+          python -m mypy.stubtest ducktools.classbuilder

ducktools_classbuilder-0.7.1/.github/workflows/publish_to_pypi.yml

@@ -0,0 +1,87 @@
+name: Publish Package to PyPi
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  build:
+    name: Build distribution 📦
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.8"
+    - name: Install pypa/build
+      run: >-
+        python3 -m
+        pip install
+        build
+        --user
+    - name: Build a binary wheel and a source tarball
+      run: python3 -m build
+    - name: Store the distribution packages
+      uses: actions/upload-artifact@v4
+      with:
+        name: python-package-distributions
+        path: dist/
+
+  publish-to-pypi:
+    name: >-
+      Publish Python 🐍 distribution 📦 to PyPI
+    needs:
+    - build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/ducktools-classbuilder
+    permissions:
+      id-token: write  # IMPORTANT: mandatory for trusted publishing
+
+    steps:
+    - name: Download all the dists
+      uses: actions/download-artifact@v4
+      with:
+        name: python-package-distributions
+        path: dist/
+    - name: Publish distribution 📦 to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
+
+  github-release:
+    name: >-
+      Sign the Python 🐍 distribution 📦 with Sigstore
+      and upload them to GitHub Release
+    needs:
+    - publish-to-pypi
+    runs-on: ubuntu-latest
+
+    permissions:
+      contents: write  # IMPORTANT: mandatory for making GitHub Releases
+      id-token: write  # IMPORTANT: mandatory for sigstore
+
+    steps:
+    - name: Download all the dists
+      uses: actions/download-artifact@v4
+      with:
+        name: python-package-distributions
+        path: dist/
+    - name: Sign the dists with Sigstore
+      uses: sigstore/gh-action-sigstore-python@v3.0.0
+      with:
+        release-signing-artifacts: false
+        inputs: >-
+          ./dist/*.tar.gz
+          ./dist/*.whl
+    - name: Upload artifact signatures to GitHub Release
+      env:
+        GITHUB_TOKEN: ${{ github.token }}
+      # Upload to GitHub Release using the `gh` CLI.
+      # `dist/` contains the built packages, and the
+      # sigstore-produced signatures and certificates.
+      run: >-
+        gh release upload
+        '${{ github.ref_name }}' dist/**
+        --repo '${{ github.repository }}'

ducktools_classbuilder-0.7.1/.github/workflows/publish_to_testpypi.yml

@@ -0,0 +1,55 @@
+name: Test Publish Package to TestPyPi
+
+on:
+  push:
+    tags:
+      - "v[0-9]+.[0-9]+.[0-9]+*"
+
+jobs:
+  build:
+    name: Build distribution 📦
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.8"
+    - name: Install pypa/build
+      run: >-
+        python3 -m
+        pip install
+        build
+        --user
+    - name: Build a binary wheel and a source tarball
+      run: python3 -m build
+    - name: Store the distribution packages
+      uses: actions/upload-artifact@v4
+      with:
+        name: python-package-distributions
+        path: dist/
+
+  publish-to-testpypi:
+    name: Publish Python 🐍 distribution 📦 to TestPyPI
+    needs:
+    - build
+    runs-on: ubuntu-latest
+
+    environment:
+      name: testpypi
+      url: https://test.pypi.org/p/ducktools-classbuilder
+
+    permissions:
+      id-token: write  # IMPORTANT: mandatory for trusted publishing
+
+    steps:
+    - name: Download all the dists
+      uses: actions/download-artifact@v4
+      with:
+        name: python-package-distributions
+        path: dist/
+    - name: Publish distribution 📦 to TestPyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        repository-url: https://test.pypi.org/legacy/

ducktools_classbuilder-0.7.1/.gitignore

@@ -0,0 +1,25 @@
+.idea
+.mypy_cache
+.pytest_cache
+references
+.coverage
+scratch/
+*.egg-info/
+build/
+_build/
+dist/
+htmlcov/
+*.lcov
+coverage.xml
+
+/env*/
+
+perftemp.py
+hyperfine_testfiles/
+
+.vscode/
+__pycache__/
+*.pyc
+
+# setuptools-scm generated version file
+_version.py

ducktools_classbuilder-0.7.1/.readthedocs.yaml

@@ -0,0 +1,24 @@
+# .readthedocs.yaml
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
+version: 2
+
+# Set the version of Python and other tools you might need
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.12"
+
+# Build documentation in the docs/ directory with Sphinx
+sphinx:
+   configuration: docs/conf.py
+
+# Optionally declare the Python requirements required to build your docs
+python:
+   install:
+     - method: pip
+       path: .
+       extra_requirements:
+         - docs

{ducktools_classbuilder-0.6.3/src/ducktools_classbuilder.egg-info → ducktools_classbuilder-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ducktools-classbuilder
-Version: 0.6.3
+Version: 0.7.1
 Summary: Toolkit for creating class boilerplate generators
 Author: David C Ellis
 License: MIT License
@@ -32,13 +32,14 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Operating System :: OS Independent
 Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
 Provides-Extra: testing
-Requires-Dist: pytest; extra == "testing"
+Requires-Dist: pytest>=8.2; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
 Requires-Dist: mypy; extra == "testing"
 Requires-Dist: typing_extensions; extra == "testing"

{ducktools_classbuilder-0.6.3 → ducktools_classbuilder-0.7.1}/docs/extension_examples.md

@@ -84,7 +84,7 @@ def iter_generator(cls, funcname="__iter__"):
     field_yield = "\n".join(f"    yield self.{f}" for f in field_names)
     if not field_yield:
         field_yield = "    yield from ()"
-    code = f"def {funcname}(self):\n" f"{field_yield}"
+    code = f"def {funcname}(self):\n{field_yield}"
     globs = {}
     return GeneratedCode(code, globs)
 
@@ -330,7 +330,7 @@ if __name__ == "__main__":
 
 This seems to be a feature people keep requesting for `dataclasses`.
 
-To implement this you simply need to create a new annotated_gatherer function.
+To implement this you need to create a new annotated_gatherer function.
 
 > Note: Field classes will be frozen when running under pytest.
 >       They should not be mutated by gatherers.

{ducktools_classbuilder-0.6.3 → ducktools_classbuilder-0.7.1}/docs/tutorial.md

@@ -1,6 +1,6 @@
 # Tutorial: Making a class boilerplate generator #
 
-The core idea is that there are 3 parts to the process of generating
+The core idea is that there are 4 parts to the process of generating
 the class boilerplate that need to be handled:
 
 1. Create a new subclass of `Field` if you need to add any extra attributes to fields
@@ -162,7 +162,7 @@ print(report_generator(CodegenDemo).source_code)
 Here we will make both a simple decorator based builder and then a subclass
 based builder that can create `__slots__`.
 
-### Decorator builder ###
+### 4a: Decorator builder ###
 ```python
 def reportclass(cls):
     gatherer = fields_attribute_gatherer
@@ -177,21 +177,22 @@ def reportclass(cls):
     flags = {"slotted": slotted}
 
     return dtbuild.builder(cls, gatherer=gatherer, methods=methods, flags=flags)
+```
 
-# Step 4b: Define a base class builder
+### 4b: Base class Builder ###
+```python
 # Once slots have been made, slot_gatherer should be used.
 slot_gatherer = dtbuild.make_slot_gatherer(CustomField)
-```
 
-### Base class Builder ###
-```python
+
 class ReportClass(metaclass=dtbuild.SlotMakerMeta):
     __slots__ = {}
     _meta_gatherer = fields_attribute_gatherer
 
     def __init_subclass__(cls):
-        slotted = '__slots__' in vars(cls) and isinstance(cls.__slots__, dtbuild.SlotFields)
-        gatherer = slot_gatherer if slotted else fields_attribute_gatherer
+        # Check if the metaclass has generated slots
+        meta_slotted = '__slots__' in vars(cls) and isinstance(cls.__slots__, dtbuild.SlotFields)
+        gatherer = slot_gatherer if meta_slotted else fields_attribute_gatherer
         methods = {
             dtbuild.eq_maker,
             dtbuild.repr_maker,
@@ -199,6 +200,7 @@ class ReportClass(metaclass=dtbuild.SlotMakerMeta):
             report_maker
         }
 
+        # The class may still have slots unrelated to code generation
         slotted = "__slots__" in vars(cls)
         flags = {"slotted": slotted}
 

ducktools_classbuilder-0.7.1/docs_code/docs_ex1_basic.py

@@ -0,0 +1,17 @@
+from ducktools.classbuilder import slotclass, Field, SlotFields
+
+
+@slotclass
+class SlottedDC:
+    __slots__ = SlotFields(
+        the_answer=42,
+        the_question=Field(
+            default="What do you get if you multiply six by nine?",
+            doc="Life, the Universe, and Everything",
+        ),
+    )
+
+
+ex = SlottedDC()
+print(ex)
+help(SlottedDC)

ducktools_classbuilder-0.7.1/docs_code/docs_ex2_register.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass
+from ducktools.classbuilder import slotclass, SlotFields
+
+class_register = {}
+
+
+def register(cls):
+    class_register[cls.__name__] = cls
+    return cls
+
+
+@dataclass(slots=True)
+@register
+class DataCoords:
+    x: float = 0.0
+    y: float = 0.0
+
+
+@slotclass
+@register
+class SlotCoords:
+    __slots__ = SlotFields(x=0.0, y=0.0)
+    # Type hints don't affect class construction, these are optional.
+    x: float
+    y: float
+
+
+print(DataCoords())
+print(SlotCoords())
+
+print(f"{DataCoords is class_register[DataCoords.__name__] = }")
+print(f"{SlotCoords is class_register[SlotCoords.__name__] = }")

ducktools_classbuilder-0.7.1/docs_code/docs_ex3_iterable.py

@@ -0,0 +1,50 @@
+from ducktools.classbuilder import (
+    default_methods,
+    get_fields,
+    slotclass,
+    GeneratedCode,
+    MethodMaker,
+    SlotFields,
+)
+
+
+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 {funcname}(self):\n{field_yield}"
+    globs = {}
+    return GeneratedCode(code, globs)
+
+
+iter_maker = MethodMaker("__iter__", iter_generator)
+new_methods = frozenset(default_methods | {iter_maker})
+
+
+def iterclass(cls=None, /):
+    return slotclass(cls, methods=new_methods)
+
+
+if __name__ == "__main__":
+    @iterclass
+    class IterDemo:
+        __slots__ = SlotFields(
+            a=1,
+            b=2,
+            c=3,
+            d=4,
+            e=5,
+        )
+
+    ex = IterDemo()
+    print([item for item in ex])
+
+
+    @iterclass
+    class IterDemo:
+        __slots__ = SlotFields()
+
+
+    ex = IterDemo()
+    print([item for item in ex])

ducktools_classbuilder-0.7.1/docs_code/docs_ex5_frozen.py

@@ -0,0 +1,43 @@
+from ducktools.classbuilder import (
+    slotclass,
+    SlotFields,
+    default_methods,
+    frozen_setattr_maker,
+    frozen_delattr_maker,
+)
+
+
+new_methods = default_methods | {frozen_setattr_maker, frozen_delattr_maker}
+
+
+def frozen(cls, /):
+    return slotclass(cls, methods=new_methods)
+
+
+if __name__ == "__main__":
+    @frozen
+    class FrozenEx:
+        __slots__ = SlotFields(
+            x=6,
+            y=9,
+            product=42,
+        )
+
+
+    ex = FrozenEx()
+    print(ex)
+
+    try:
+        ex.y = 7
+    except TypeError as e:
+        print(e)
+
+    try:
+        ex.z = "new value"
+    except TypeError as e:
+        print(e)
+
+    try:
+        del ex.y
+    except TypeError as e:
+        print(e)

ducktools_classbuilder-0.7.1/docs_code/docs_ex7_posonly.py

@@ -0,0 +1,131 @@
+from ducktools.classbuilder import (
+    builder,
+    eq_maker,
+    get_fields,
+    slot_gatherer,
+    Field,
+    GeneratedCode,
+    SlotFields,
+    NOTHING,
+    MethodMaker,
+)
+
+
+class PosOnlyField(Field):
+    __slots__ = SlotFields(pos_only=True)
+
+
+def init_generator(cls, funcname="__init__"):
+    fields = get_fields(cls)
+
+    arglist = []
+    assignments = []
+    globs = {}
+
+    used_posonly = False
+    used_kw = False
+
+    for k, v in fields.items():
+        if getattr(v, "pos_only", False):
+            used_posonly = True
+        elif used_posonly and not used_kw:
+            used_kw = True
+            arglist.append("/")
+
+        if v.default is not NOTHING:
+            globs[f"_{k}_default"] = v.default
+            arg = f"{k}=_{k}_default"
+            assignment = f"self.{k} = {k}"
+        elif v.default_factory is not NOTHING:
+            globs[f"_{k}_factory"] = v.default_factory
+            arg = f"{k}=None"
+            assignment = f"self.{k} = _{k}_factory() if {k} is None else {k}"
+        else:
+            arg = f"{k}"
+            assignment = f"self.{k} = {k}"
+
+        arglist.append(arg)
+        assignments.append(assignment)
+
+    args = ", ".join(arglist)
+    assigns = "\n    ".join(assignments)
+    code = f"def {funcname}(self, {args}):\n" f"    {assigns}\n"
+    return GeneratedCode(code, globs)
+
+
+def repr_generator(cls, funcname="__repr__"):
+    fields = get_fields(cls)
+    content_list = []
+    for name, field in fields.items():
+        if getattr(field, "pos_only", False):
+            assign = f"{{self.{name}!r}}"
+        else:
+            assign = f"{name}={{self.{name}!r}}"
+        content_list.append(assign)
+
+    content = ", ".join(content_list)
+    code = (
+        f"def {funcname}(self):\n"
+        f"    return f'{{type(self).__qualname__}}({content})'\n"
+    )
+    globs = {}
+    return GeneratedCode(code, globs)
+
+
+init_maker = MethodMaker("__init__", init_generator)
+repr_maker = MethodMaker("__repr__", repr_generator)
+new_methods = frozenset({init_maker, repr_maker, eq_maker})
+
+
+def pos_slotclass(cls, /):
+    cls = builder(
+        cls,
+        gatherer=slot_gatherer,
+        methods=new_methods,
+    )
+
+    # Check no positional-only args after keyword args
+    flds = get_fields(cls)
+    used_kwarg = False
+    for k, v in flds.items():
+        if getattr(v, "pos_only", False):
+            if used_kwarg:
+                raise SyntaxError(
+                    f"Positional only parameter {k!r}"
+                    f" follows keyword parameters on {cls.__name__!r}"
+                )
+        else:
+            used_kwarg = True
+
+    return cls
+
+
+if __name__ == "__main__":
+    @pos_slotclass
+    class WorkingEx:
+        __slots__ = SlotFields(
+            a=PosOnlyField(default=42),
+            x=6,
+            y=9,
+        )
+
+    ex = WorkingEx()
+    print(ex)
+    ex = WorkingEx(42, x=6, y=9)
+    print(ex)
+
+    try:
+        ex = WorkingEx(a=54)
+    except TypeError as e:
+        print(e)
+
+    try:
+        @pos_slotclass
+        class FailEx:
+            __slots__ = SlotFields(
+                a=42,
+                x=PosOnlyField(default=6),
+                y=PosOnlyField(default=9),
+            )
+    except SyntaxError as e:
+        print(e)

ducktools_classbuilder-0.7.1/docs_code/docs_ex8_converters.py

@@ -0,0 +1,57 @@
+from ducktools.classbuilder import (
+    builder,
+    default_methods,
+    get_fields,
+    slot_gatherer,
+    Field,
+    GeneratedCode,
+    SlotFields,
+    MethodMaker,
+)
+
+
+class ConverterField(Field):
+    converter = Field(default=None)
+
+
+def setattr_generator(cls, funcname="__setattr__"):
+    fields = get_fields(cls)
+    converters = {}
+    for k, v in fields.items():
+        if conv := getattr(v, "converter", None):
+            converters[k] = conv
+
+    globs = {
+        "_converters": converters,
+        "_object_setattr": object.__setattr__,
+    }
+
+    code = (
+        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"
+        f"        _object_setattr(self, name, value)\n"
+    )
+
+    return GeneratedCode(code, globs)
+
+
+setattr_maker = MethodMaker("__setattr__", setattr_generator)
+methods = frozenset(default_methods | {setattr_maker})
+
+
+def converterclass(cls, /):
+    return builder(cls, gatherer=slot_gatherer, methods=methods)
+
+
+if __name__ == "__main__":
+    @converterclass
+    class ConverterEx:
+        __slots__ = SlotFields(
+            unconverted=ConverterField(),
+            converted=ConverterField(converter=int),
+        )
+
+    ex = ConverterEx("42", "42")
+    print(ex)