circuitpython-functools 2.0.3__tar.gz → 3.0.0__tar.gz

circuitpython_functools-3.0.0/.github/workflows/codecov.yml

@@ -0,0 +1,43 @@
+# SPDX-FileCopyrightText: 2026 Alec Delaney
+# SPDX-License-Identifier: MIT
+
+name: Run code tests
+
+on:
+  push:
+    branches:
+      - 'main'
+  pull_request:
+    paths:
+      - '.github/workflows/codecov.yml'
+      - 'pyproject.toml'
+      - 'circuitpython_functools'
+      - 'tests/**'
+
+permissions: read-all
+
+jobs:
+  codecov:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Setup Python 3.x
+        uses: actions/setup-python@v6
+        with:
+          python-version: ${{ matrix.py-version }}
+      - name: Checkout the repository
+        uses: actions/checkout@v6
+      - name: Install base requirements
+        run: |
+          pip install ".[optional]"
+      - name: Install test requirements
+        run: |
+          pip install pytest pytest-cov
+      - name: Run tests
+        run: |
+          pytest --cov --cov-branch --cov-report=xml
+      - name: Upload coverage reports to Codecov
+        uses: codecov/codecov-action@v5
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          fail_ci_if_error: true

{circuitpython_functools-2.0.3/circuitpython_functools.egg-info → circuitpython_functools-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: circuitpython-functools
-Version: 2.0.3
+Version: 3.0.0
 Summary: A CircuitPython implementation of CPython's functools library
 Author-email: Alec Delaney <tekktrik@gmail.com>
 License-Expression: MIT AND PSF-2.0

{circuitpython_functools-2.0.3 → circuitpython_functools-3.0.0/circuitpython_functools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: circuitpython-functools
-Version: 2.0.3
+Version: 3.0.0
 Summary: A CircuitPython implementation of CPython's functools library
 Author-email: Alec Delaney <tekktrik@gmail.com>
 License-Expression: MIT AND PSF-2.0

{circuitpython_functools-2.0.3 → circuitpython_functools-3.0.0}/circuitpython_functools.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ requirements.txt
 .github/dependabot.yml
 .github/PULL_REQUEST_TEMPLATE/adafruit_circuitpython_pr.md
 .github/workflows/build.yml
+.github/workflows/codecov.yml
 .github/workflows/failure-help-text.yml
 .github/workflows/release_gh.yml
 .github/workflows/release_pypi.yml
@@ -35,4 +36,9 @@ docs/index.rst.license
 docs/requirements.txt
 docs/_static/favicon.ico
 docs/_static/favicon.ico.license
-examples/functools_simpletest.py
+examples/functools_simpletest.py
+tests/test_cache.py
+tests/test_lru_cache.py
+tests/test_partial.py
+tests/test_total_ordering.py
+tests/test_wraps.py

{circuitpython_functools-2.0.3 → circuitpython_functools-3.0.0}/circuitpython_functools.py

@@ -23,7 +23,7 @@ Implementation Notes
 import gc
 from collections import OrderedDict
 
-__version__ = "2.0.3"
+__version__ = "3.0.0"
 __repo__ = "https://github.com/tekktrik/CircuitPython_functools.git"
 
 _cache_records = {}
@@ -146,4 +146,70 @@ def partial(func, *args, **kwargs):
 # their simplified implementation of the wraps function!
 def wraps(wrapped, assigned=None, updated=None):
     """Define a wrapper function when writing function decorators."""
-    return wrapped
+
+    def decorator(wrapper):
+        return wrapper
+
+    return decorator
+
+
+def total_ordering(cls):  # noqa: PLR0912
+    """Automatically create the comparison functions."""
+    has_lt = "__lt__" in cls.__dict__
+    has_gt = "__gt__" in cls.__dict__
+    has_le = "__le__" in cls.__dict__
+    has_ge = "__ge__" in cls.__dict__
+
+    if not (has_lt or has_gt or has_le or has_ge):
+        raise ValueError("must define at least one ordering operation: < > <= >=")
+
+    def instance_guard(x, cls):
+        if not isinstance(x, cls):
+            raise TypeError("unsupport comparison")
+        return True
+
+    if not has_lt:
+        if has_le:
+            lt_func = lambda self, other: self <= other and self != other
+        elif has_gt:
+            lt_func = lambda self, other: not (self > other) and self != other
+        else:  # has_ge
+            lt_func = lambda self, other: not (self >= other)
+        cls.__lt__ = lambda self, other: instance_guard(other, cls) and lt_func(
+            self, other
+        )
+
+    if not has_le:
+        if has_lt:
+            le_func = lambda self, other: self < other or self == other
+        elif has_gt:
+            le_func = lambda self, other: not (self > other)
+        else:  # has_ge
+            le_func = lambda self, other: self == other or not (self >= other)
+        cls.__le__ = lambda self, other: instance_guard(other, cls) and le_func(
+            self, other
+        )
+
+    if not has_gt:
+        if has_lt:
+            gt_func = lambda self, other: self != other and not (self < other)
+        elif has_ge:
+            gt_func = lambda self, other: self >= other and self != other
+        else:  # has_le
+            gt_func = lambda self, other: not (self <= other)
+        cls.__gt__ = lambda self, other: instance_guard(other, cls) and gt_func(
+            self, other
+        )
+
+    if not has_ge:
+        if has_lt:
+            ge_func = lambda self, other: not (self < other)
+        elif has_gt:
+            ge_func = lambda self, other: self > other or self == other
+        else:  # has_le
+            ge_func = lambda self, other: self == other or not (self <= other)
+        cls.__ge__ = lambda self, other: instance_guard(other, cls) and ge_func(
+            self, other
+        )
+
+    return cls

{circuitpython_functools-2.0.3 → circuitpython_functools-3.0.0}/pyproject.toml

@@ -12,7 +12,7 @@ requires = [
 [project]
 name = "circuitpython-functools"
 description = "A CircuitPython implementation of CPython's functools library"
-version = "2.0.3"
+version = "3.0.0"
 readme = "README.rst"
 authors = [
     {name = "Alec Delaney", email = "tekktrik@gmail.com"}

circuitpython_functools-3.0.0/tests/test_cache.py

@@ -0,0 +1,34 @@
+# SPDX-FileCopyrightText: 2026 Alec Delaney
+# SPDX-FileCopyrightText: Python Software Foundation
+
+# SPDX-License-Identifier: MIT
+# SPDX-License-Identifier: PSF-2.0
+
+"""Tests for cache."""
+
+from circuitpython_functools import cache
+
+# Example adapted from CPython documentation
+
+TOTAL_CALLS = 0
+
+
+def test_cache():
+    """Tests that cache decorator works as expected."""
+
+    @cache
+    def factorial(n):
+        global TOTAL_CALLS  # noqa: PLW0603
+        TOTAL_CALLS += 1
+        return n * factorial(n - 1) if n else 1
+
+    assert TOTAL_CALLS == 0  # noqa: PLR2004
+
+    _ = factorial(10)
+    assert TOTAL_CALLS == 11  # noqa: PLR2004
+
+    _ = factorial(5)
+    assert TOTAL_CALLS == 11  # noqa: PLR2004
+
+    _ = factorial(12)
+    assert TOTAL_CALLS == 13  # noqa: PLR2004

circuitpython_functools-3.0.0/tests/test_lru_cache.py

@@ -0,0 +1,165 @@
+# SPDX-FileCopyrightText: 2026 Alec Delaney
+# SPDX-FileCopyrightText: Python Software Foundation
+#
+# SPDX-License-Identifier: MIT
+# SPDX-License-Identifier: PSF-2.0
+
+"""Tests for lru_cache."""
+
+import pytest
+
+from circuitpython_functools import _lru_cache_records, lru_cache
+
+# Factorial example adapted from CPython documentation
+
+TOTAL_CALLS = 0
+
+
+def test_lru_cache_default():
+    """Tests the lru_cache works with default settings (no arguments provided)."""
+    global TOTAL_CALLS  # noqa: PLW0603
+
+    @lru_cache
+    def factorial(n):
+        global TOTAL_CALLS  # noqa: PLW0603
+        TOTAL_CALLS += 1
+        return n * factorial(n - 1) if n else 1
+
+    assert TOTAL_CALLS == 0  # noqa: PLR2004
+
+    _ = factorial(10)
+    assert TOTAL_CALLS == 11  # noqa: PLR2004
+
+    _ = factorial(5)
+    assert TOTAL_CALLS == 11  # noqa: PLR2004
+
+    _ = factorial(12)
+    assert TOTAL_CALLS == 13  # noqa: PLR2004
+
+    TOTAL_CALLS = 0
+
+
+def test_lru_cache_maxsize_arg():
+    """Tests the lru_cache maxsize function when given as arg."""
+    global TOTAL_CALLS  # noqa: PLW0603
+
+    @lru_cache(5)
+    def factorial(n):
+        global TOTAL_CALLS  # noqa: PLW0603
+        TOTAL_CALLS += 1
+        return n * factorial(n - 1) if n else 1
+
+    assert TOTAL_CALLS == 0  # noqa: PLR2004
+
+    _ = factorial(10)
+    assert TOTAL_CALLS == 11  # noqa: PLR2004
+    print("---")
+
+    _ = factorial(5)
+    assert TOTAL_CALLS == 17  # noqa: PLR2004
+    print("---")
+
+    _ = factorial(12)
+    assert TOTAL_CALLS == 24  # noqa: PLR2004
+
+    TOTAL_CALLS = 0
+
+
+def test_lru_cache_maxsize_kwarg():
+    """Tests the lru_cache maxsize function when given as kwarg."""
+    global TOTAL_CALLS  # noqa: PLW0603
+
+    @lru_cache(maxsize=5)
+    def factorial(n):
+        global TOTAL_CALLS  # noqa: PLW0603
+        TOTAL_CALLS += 1
+        return n * factorial(n - 1) if n else 1
+
+    assert TOTAL_CALLS == 0  # noqa: PLR2004
+
+    _ = factorial(10)
+    assert TOTAL_CALLS == 11  # noqa: PLR2004
+    print("---")
+
+    _ = factorial(5)
+    assert TOTAL_CALLS == 17  # noqa: PLR2004
+    print("---")
+
+    _ = factorial(12)
+    assert TOTAL_CALLS == 24  # noqa: PLR2004
+
+    TOTAL_CALLS = 0
+
+
+def test_lru_cache_func_kwarg():
+    """Tests the lru_cache when function has kwargs."""
+    global TOTAL_CALLS  # noqa: PLW0603
+
+    @lru_cache
+    def factorial(*, n):
+        global TOTAL_CALLS  # noqa: PLW0603
+        TOTAL_CALLS += 1
+        return n * factorial(n=n - 1) if n else 1
+
+    assert TOTAL_CALLS == 0  # noqa: PLR2004
+
+    _ = factorial(n=10)
+    assert TOTAL_CALLS == 11  # noqa: PLR2004
+
+    _ = factorial(n=5)
+    assert TOTAL_CALLS == 11  # noqa: PLR2004
+
+    _ = factorial(n=12)
+    assert TOTAL_CALLS == 13  # noqa: PLR2004
+
+    TOTAL_CALLS = 0
+
+
+def test_lru_cache_cache_clear():
+    """Tests the automatically attached cache_clear method works."""
+    global TOTAL_CALLS  # noqa: PLW0603
+
+    @lru_cache
+    def factorial(n):
+        global TOTAL_CALLS  # noqa: PLW0603
+        TOTAL_CALLS += 1
+        return n * factorial(n=n - 1) if n else 1
+
+    assert TOTAL_CALLS == 0  # noqa: PLR2004
+
+    _ = factorial(n=10)
+    assert TOTAL_CALLS == 11  # noqa: PLR2004
+
+    factorial.cache_clear()
+
+    _ = factorial(n=10)
+    assert TOTAL_CALLS == 22  # noqa: PLR2004
+
+    TOTAL_CALLS = 0
+
+
+def test_lru_cache_typed_error_args():
+    """Tests that lru_cache raises an error if "typed" given as arg."""
+    with pytest.raises(NotImplementedError):
+
+        @lru_cache(100, True)
+        def factorial(n):
+            return n * factorial(n=n - 1) if n else 1
+
+
+def test_lru_cache_typed_error_kwargs():
+    """Tests that lru_cache raises an error if "typed" given as kwarg."""
+    with pytest.raises(NotImplementedError):
+
+        @lru_cache(typed=True)
+        def factorial(n):
+            return n * factorial(n=n - 1) if n else 1
+
+
+def test_lru_cache_syntax_error():
+    """Tests that lru_cache raises an error if arguments are incorrect."""
+    with pytest.raises(SyntaxError):
+
+        @lru_cache(100, True, "a")
+        def factorial(n):
+            return n * factorial(n=n - 1) if n else 1

circuitpython_functools-3.0.0/tests/test_partial.py

@@ -0,0 +1,26 @@
+# SPDX-FileCopyrightText: 2026 Alec Delaney
+#
+# SPDX-License-Identifier: MIT
+
+"""Tests for partial."""
+
+from circuitpython_functools import partial
+
+
+def test_partial():
+    """Tests functionality of partial."""
+
+    def towerize(x, y, z):
+        return (x * 100) + (y * 10) + z
+
+    towerize100 = partial(towerize, 1)
+    assert towerize100(5, 3) == 153  # noqa: PLR2004
+    assert towerize100(z=2, y=7) == 172  # noqa: PLR2004
+
+    towerize150 = partial(towerize, 1, 5)
+    assert towerize150(6) == 156  # noqa: PLR2004
+    assert towerize150(z=8) == 158  # noqa: PLR2004
+
+    towerize20 = partial(towerize, y=2)
+    assert towerize20(9, z=0) == 920  # noqa: PLR2004
+    assert towerize20(z=1, x=5) == 521  # noqa: PLR2004

circuitpython_functools-3.0.0/tests/test_total_ordering.py

@@ -0,0 +1,124 @@
+# SPDX-FileCopyrightText: 2026 Alec Delaney
+# SPDX-License-Identifier: MIT
+
+"""Tests for total_ordering."""
+
+import pytest
+
+from circuitpython_functools import total_ordering
+
+
+class BaseClass:
+    """Basic test base class."""
+
+    def __init__(self, attr):
+        """Initialize the instance."""
+        self.attr = attr
+
+    def __eq__(self, other):
+        """Perform basic equal to operation."""
+        if not isinstance(other, BaseClass):
+            return False
+        return self.attr == other.attr
+
+
+class OtherClass:
+    """A different class."""
+
+
+parameters = []
+
+
+@total_ordering
+class UsesLT(BaseClass):
+    """Basic class that implements less than."""
+
+    def __lt__(self, other):
+        """Perform basic less than operation."""
+        if not isinstance(other, BaseClass):
+            raise TypeError
+        return self.attr < other.attr
+
+
+parameters.append((UsesLT(1), UsesLT(1), UsesLT(2)))
+
+
+@total_ordering
+class UsesGT(BaseClass):
+    """Basic class that implements greater than."""
+
+    def __gt__(self, other):
+        """Perform basic greater than operation."""
+        if not isinstance(other, BaseClass):
+            raise TypeError
+        return self.attr > other.attr
+
+
+parameters.append((UsesGT(1), UsesGT(1), UsesGT(2)))
+
+
+@total_ordering
+class UsesLE(BaseClass):
+    """Basic class that implements less than or equal to."""
+
+    def __le__(self, other):
+        """Perform basic less than or equal to operation."""
+        if not isinstance(other, BaseClass):
+            raise TypeError
+        return self.attr <= other.attr
+
+
+parameters.append((UsesLE(1), UsesLE(1), UsesLE(2)))
+
+
+@total_ordering
+class UsesGE(BaseClass):
+    """Basic class that implements greater than or equal to."""
+
+    def __ge__(self, other):
+        """Perform basic greater than or equal to operation."""
+        if not isinstance(other, BaseClass):
+            raise TypeError
+        return self.attr >= other.attr
+
+
+parameters.append((UsesGE(1), UsesGE(1), UsesGE(2)))
+
+
+@pytest.mark.parametrize("x,y,z", parameters)
+def test_comparisons(x, y, z):
+    """Tests that comparisons are correct."""
+    w = OtherClass()
+
+    # lt
+    assert not x < y
+    assert x < z
+    with pytest.raises(TypeError):
+        x < w
+
+    # gt
+    assert not x > y
+    assert z > x
+    with pytest.raises(TypeError):
+        x > w
+
+    # le
+    assert x <= y
+    assert x <= z
+    with pytest.raises(TypeError):
+        x <= w
+
+    # ge
+    assert x >= y
+    assert not x >= z
+    with pytest.raises(TypeError):
+        x >= w
+
+
+def test_none_implemented():
+    """Tests the not implementig compraison function results in an error."""
+    with pytest.raises(ValueError):
+
+        @total_ordering
+        class NoneImplemented:
+            """Class with nothing implemented."""

circuitpython_functools-3.0.0/tests/test_wraps.py

@@ -0,0 +1,28 @@
+# SPDX-FileCopyrightText: 2026 Alec Delaney
+# SPDX-License-Identifier: MIT
+
+"""Tests for wraps."""
+
+from circuitpython_functools import wraps
+
+
+def square_args(func):
+    """Square arguments before calling function."""
+
+    @wraps(func)
+    def wrapper(x, y):
+        a = x**2
+        b = y**2
+        return func(a, b)
+
+    return wrapper
+
+
+def test_wraps():
+    """Tests that x is x."""
+
+    @square_args
+    def add2(aa, bb):
+        return aa + bb
+
+    assert add2(3, 4) == 25  # noqa: PLR2004