ovld 0.3.6__tar.gz → 0.3.8__tar.gz

{ovld-0.3.6 → ovld-0.3.8}/.github/workflows/python-package.yml

@@ -30,18 +30,32 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ['3.8', '3.9', '3.10', '3.11', '3.12']
+        settings:
+        - python: '3.8'
+          coverage: false
+        - python: '3.9'
+          coverage: false
+        - python: '3.10'
+          coverage: false
+        - python: '3.11'
+          coverage: false
+        - python: '3.12'
+          coverage: true
     steps:
     - name: Check out the code
       uses: actions/checkout@v3
     - name: Install rye
       uses: eifinger/setup-rye@v4
     - name: Pin Python version
-      run: rye pin ${{ matrix.python-version }}
+      run: rye pin ${{ matrix.settings.python }}
     - name: Sync dependencies
       run: rye sync
     - name: Test with pytest
-      run: rye run pytest --cov=ovld --cov-report term-missing
+      if: ${{ !matrix.settings.coverage }}
+      run: rye run pytest
+    - name: Test with pytest and coverage
+      if: ${{ matrix.settings.coverage }}
+      run: rye run pytest --cov=src --cov-report term-missing
     - name: Verify coverage
-      if: ${{ matrix.python-version == '3.12' }}
+      if: ${{ matrix.settings.coverage }}
       run: rye run coverage report | tail -1 | egrep "TOTAL +[0-9]+ +0 +100%"

{ovld-0.3.6 → ovld-0.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ovld
-Version: 0.3.6
+Version: 0.3.8
 Summary: Overloading Python functions
 Author-email: Olivier Breuleux <breuleux@gmail.com>
 License-Expression: MIT

ovld-0.3.8/bench.py

@@ -0,0 +1,136 @@
+import timeit
+
+from multimethod import multimethod
+from multipledispatch import dispatch
+from ovld import ovld
+
+# OVLD
+
+
+@ovld
+def smap(x: list, y: list):
+    """One."""
+    return [smap(a, b) for a, b in zip(x, y)]
+
+
+@ovld
+def smap(x: tuple, y: tuple):
+    return tuple(smap(a, b) for a, b in zip(x, y))
+
+
+@ovld
+def smap(x: dict, y: dict):
+    return {k: smap(v, y[k]) for k, v in x.items()}
+
+
+@ovld
+def smap(x: object, y: object):
+    return x + y
+
+
+# OVLD B
+
+
+@ovld
+def smap_b(self, x: list, y: list):
+    """Two."""
+    return [self(a, b) for a, b in zip(x, y)]
+
+
+@ovld
+def smap_b(self, x: tuple, y: tuple):
+    return tuple(self(a, b) for a, b in zip(x, y))
+
+
+@ovld
+def smap_b(self, x: dict, y: dict):
+    return {k: self(v, y[k]) for k, v in x.items()}
+
+
+@ovld
+def smap_b(self, x: object, y: object):
+    return x + y
+
+
+# multimethods
+
+
+@multimethod
+def smap_mm(x: list, y: list):
+    """Three."""
+    return [smap_mm(a, b) for a, b in zip(x, y)]
+
+
+@multimethod
+def smap_mm(x: tuple, y: tuple):
+    return tuple(smap_mm(a, b) for a, b in zip(x, y))
+
+
+@multimethod
+def smap_mm(x: dict, y: dict):
+    return {k: smap_mm(v, y[k]) for k, v in x.items()}
+
+
+@multimethod
+def smap_mm(x: object, y: object):
+    return x + y
+
+
+# multipledispatch
+
+
+@dispatch(list, list)
+def smap_md(x, y):
+    """Four."""
+    return [smap_md(a, b) for a, b in zip(x, y)]
+
+
+@dispatch(tuple, tuple)
+def smap_md(x, y):
+    return tuple(smap_md(a, b) for a, b in zip(x, y))
+
+
+@dispatch(dict, dict)
+def smap_md(x, y):
+    return {k: smap_md(v, y[k]) for k, v in x.items()}
+
+
+@dispatch(object, object)
+def smap_md(x, y):
+    return x + y
+
+
+# isinstance
+
+
+def smap_ii(x, y):
+    """Five."""
+    if isinstance(x, dict) and isinstance(y, dict):
+        return {k: smap_ii(v, y[k]) for k, v in x.items()}
+    elif isinstance(x, tuple) and isinstance(y, tuple):
+        return tuple(smap_ii(a, b) for a, b in zip(x, y))
+    elif isinstance(x, list) and isinstance(y, list):
+        return [smap_ii(a, b) for a, b in zip(x, y)]
+    else:
+        return x + y
+
+
+# multipledispatch
+
+
+A = {"xs": list(range(50)), "ys": ("o", (6, 7))}
+B = {"xs": list(range(10, 60)), "ys": ("x", (7, 6))}
+
+print(smap(A, B))
+print(smap_mm(A, B))
+print(smap_md(A, B))
+print(smap_ii(A, B))
+print(smap_b(A, B))
+
+# breakpoint()
+
+print("smap_ov\t", timeit.timeit(lambda: smap(A, B), number=10000))
+print("smap_mm\t", timeit.timeit(lambda: smap_mm(A, B), number=10000))
+print("smap_md\t", timeit.timeit(lambda: smap_md(A, B), number=10000))
+print("smap_ii\t", timeit.timeit(lambda: smap_ii(A, B), number=10000))
+print("smap_b\t", timeit.timeit(lambda: smap_b(A, B), number=10000))

{ovld-0.3.6 → ovld-0.3.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ovld"
-version = "0.3.6"
+version = "0.3.8"
 description = "Overloading Python functions"
 authors = [
     { name = "Olivier Breuleux", email = "breuleux@gmail.com" }
@@ -19,9 +19,10 @@ build-backend = "hatchling.build"
 [tool.rye]
 managed = true
 dev-dependencies = [
-    "codefind>=0.1.6",
+    "codefind~=0.1.6",
     "pytest>=8.3.2",
     "pytest-cov>=5.0.0",
+    "uv>=0.2.30",
 ]
 
 [tool.hatch.metadata]

{ovld-0.3.6 → ovld-0.3.8}/requirements-dev.lock

@@ -22,3 +22,4 @@ pluggy==1.5.0
 pytest==8.3.2
     # via pytest-cov
 pytest-cov==5.0.0
+uv==0.2.30

ovld-0.3.8/src/ovld/__init__.py

@@ -0,0 +1,48 @@
+from .core import (
+    MultiTypeMap,
+    Ovld,
+    OvldBase,
+    OvldCall,
+    OvldMC,
+    TypeMap,
+    extend_super,
+    is_ovld,
+    ovld,
+    ovld_dispatch,
+)
+from .utils import (
+    BOOTSTRAP,
+    MISSING,
+    Dataclass,
+    Named,
+    deferred,
+    exactly,
+    has_attribute,
+    keyword_decorator,
+    meta,
+    strict_subclass,
+)
+from .version import version as __version__
+
+__all__ = [
+    "MultiTypeMap",
+    "Ovld",
+    "OvldBase",
+    "OvldCall",
+    "OvldMC",
+    "TypeMap",
+    "extend_super",
+    "is_ovld",
+    "ovld",
+    "ovld_dispatch",
+    "BOOTSTRAP",
+    "MISSING",
+    "Dataclass",
+    "Named",
+    "deferred",
+    "exactly",
+    "has_attribute",
+    "meta",
+    "keyword_decorator",
+    "strict_subclass",
+]

{ovld-0.3.6 → ovld-0.3.8}/src/ovld/core.py

@@ -115,6 +115,8 @@ class MultiTypeMap(dict):
     def transform(self, obj):
         if isinstance(obj, GenericAlias):
             return type[obj.__origin__]
+        elif obj is typing.Any:
+            return type[object]
         elif isinstance(obj, type):
             return type[obj]
         else:

ovld-0.3.8/src/ovld/version.py

@@ -0,0 +1 @@
+version = "0.3.8"

{ovld-0.3.6 → ovld-0.3.8}/tests/test_ovld.py

@@ -1108,6 +1108,22 @@ def test_generic_type_argument():
     assert f(dict[str, int]) == "dict"
 
 
+@pytest.mark.skipif(
+    sys.version_info < (3, 9),
+    reason="type[...] syntax requires python3.9 or higher",
+)
+def test_any():
+    @ovld
+    def f(t: type[dict]):
+        return "no"
+
+    @ovld
+    def f(t: type[object]):
+        return "yes"
+
+    assert f(typing.Any) == "yes"
+
+
 @pytest.mark.skipif(
     sys.version_info < (3, 9),
     reason="type[...] syntax requires python3.9 or higher",

ovld-0.3.8/x.py

@@ -0,0 +1,11 @@
+from typing import Any
+
+from ovld import ovld
+
+
+@ovld
+def test(x: type[object]):
+    return "yes"
+
+
+print(test(Any))

ovld-0.3.6/src/ovld/__init__.py

@@ -1,3 +0,0 @@
-from .core import *
-from .utils import *
-from .version import version as __version__

ovld-0.3.6/src/ovld/version.py

@@ -1 +0,0 @@
-version = "0.3.6"