ovld 0.4.3__tar.gz → 0.4.5__tar.gz

{ovld-0.4.3 → ovld-0.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ovld
-Version: 0.4.3
+Version: 0.4.5
 Summary: Overloading Python functions
 Project-URL: Homepage, https://ovld.readthedocs.io/en/latest/
 Project-URL: Documentation, https://ovld.readthedocs.io/en/latest/
@@ -201,16 +201,17 @@ assert Two().f("s") == "a string"
 
 # Benchmarks
 
-`ovld` is pretty fast: the overhead is comparable to `isinstance` or `match`, and only 2-3x slower when dispatching on `Literal` types. Compared to other multiple dispatch libraries, it is 1.5x to 100x faster.
+`ovld` is pretty fast: the overhead is comparable to `isinstance` or `match`, and only 2-3x slower when dispatching on `Literal` types. Compared to other multiple dispatch libraries, it has 1.5x to 100x less overhead.
 
 Time relative to the fastest implementation (1.00) (lower is better).
 
-| Bench | custom | [ovld](https://github.com/breuleux/ovld) | [plum](https://github.com/beartype/plum) | [multim](https://github.com/coady/multimethod) | [multid](https://github.com/mrocklin/multipledispatch/) | [runtype](https://github.com/erezsh/runtype) | [fastcore](https://github.com/fastai/fastcore) | [singled](https://docs.python.org/3/library/functools.html#functools.singledispatch) |
+| Benchmark | custom | [ovld](https://github.com/breuleux/ovld) | [plum](https://github.com/beartype/plum) | [multim](https://github.com/coady/multimethod) | [multid](https://github.com/mrocklin/multipledispatch/) | [runtype](https://github.com/erezsh/runtype) | [fastcore](https://github.com/fastai/fastcore) | [sd](https://docs.python.org/3/library/functools.html#functools.singledispatch) |
 | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
-|[trivial](https://github.com/breuleux/ovld/tree/master/benchmarks/test_trivial.py)|1.14|1.00|2.53|3.64|1.61|1.86|41.31|1.54|
-|[add](https://github.com/breuleux/ovld/tree/master/benchmarks/test_add.py)|1.01|1.00|3.46|4.83|2.21|2.66|56.08|x|
-|[multer](https://github.com/breuleux/ovld/tree/master/benchmarks/test_multer.py)|1.00|1.06|9.79|4.11|7.19|1.89|40.37|6.34|
-|[ast](https://github.com/breuleux/ovld/tree/master/benchmarks/test_ast.py)|1.00|1.06|23.07|3.04|1.68|1.87|29.11|1.63|
-|[calc](https://github.com/breuleux/ovld/tree/master/benchmarks/test_calc.py)|1.00|1.96|80.00|43.21|x|x|x|x|
-|[fib](https://github.com/breuleux/ovld/tree/master/benchmarks/test_fib.py)|1.00|3.58|438.97|123.58|x|x|x|x|
-|[tweak](https://github.com/breuleux/ovld/tree/master/benchmarks/test_tweaknum.py)|1.00|2.59|x|x|x|x|x|x|
+|[trivial](https://github.com/breuleux/ovld/tree/master/benchmarks/test_trivial.py)|1.45|1.00|3.32|4.63|2.04|2.41|51.93|1.91|
+|[multer](https://github.com/breuleux/ovld/tree/master/benchmarks/test_multer.py)|1.13|1.00|11.05|4.53|8.31|2.19|46.74|7.32|
+|[add](https://github.com/breuleux/ovld/tree/master/benchmarks/test_add.py)|1.08|1.00|3.73|5.21|2.37|2.79|59.31|x|
+|[ast](https://github.com/breuleux/ovld/tree/master/benchmarks/test_ast.py)|1.00|1.08|23.14|3.09|1.68|1.91|28.39|1.66|
+|[calc](https://github.com/breuleux/ovld/tree/master/benchmarks/test_calc.py)|1.00|1.23|54.61|29.32|x|x|x|x|
+|[regexp](https://github.com/breuleux/ovld/tree/master/benchmarks/test_regexp.py)|1.00|1.87|19.18|x|x|x|x|x|
+|[fib](https://github.com/breuleux/ovld/tree/master/benchmarks/test_fib.py)|1.00|3.30|444.31|125.77|x|x|x|x|
+|[tweaknum](https://github.com/breuleux/ovld/tree/master/benchmarks/test_tweaknum.py)|1.00|2.09|x|x|x|x|x|x|

{ovld-0.4.3 → ovld-0.4.5}/README.md

@@ -188,16 +188,17 @@ assert Two().f("s") == "a string"
 
 # Benchmarks
 
-`ovld` is pretty fast: the overhead is comparable to `isinstance` or `match`, and only 2-3x slower when dispatching on `Literal` types. Compared to other multiple dispatch libraries, it is 1.5x to 100x faster.
+`ovld` is pretty fast: the overhead is comparable to `isinstance` or `match`, and only 2-3x slower when dispatching on `Literal` types. Compared to other multiple dispatch libraries, it has 1.5x to 100x less overhead.
 
 Time relative to the fastest implementation (1.00) (lower is better).
 
-| Bench | custom | [ovld](https://github.com/breuleux/ovld) | [plum](https://github.com/beartype/plum) | [multim](https://github.com/coady/multimethod) | [multid](https://github.com/mrocklin/multipledispatch/) | [runtype](https://github.com/erezsh/runtype) | [fastcore](https://github.com/fastai/fastcore) | [singled](https://docs.python.org/3/library/functools.html#functools.singledispatch) |
+| Benchmark | custom | [ovld](https://github.com/breuleux/ovld) | [plum](https://github.com/beartype/plum) | [multim](https://github.com/coady/multimethod) | [multid](https://github.com/mrocklin/multipledispatch/) | [runtype](https://github.com/erezsh/runtype) | [fastcore](https://github.com/fastai/fastcore) | [sd](https://docs.python.org/3/library/functools.html#functools.singledispatch) |
 | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
-|[trivial](https://github.com/breuleux/ovld/tree/master/benchmarks/test_trivial.py)|1.14|1.00|2.53|3.64|1.61|1.86|41.31|1.54|
-|[add](https://github.com/breuleux/ovld/tree/master/benchmarks/test_add.py)|1.01|1.00|3.46|4.83|2.21|2.66|56.08|x|
-|[multer](https://github.com/breuleux/ovld/tree/master/benchmarks/test_multer.py)|1.00|1.06|9.79|4.11|7.19|1.89|40.37|6.34|
-|[ast](https://github.com/breuleux/ovld/tree/master/benchmarks/test_ast.py)|1.00|1.06|23.07|3.04|1.68|1.87|29.11|1.63|
-|[calc](https://github.com/breuleux/ovld/tree/master/benchmarks/test_calc.py)|1.00|1.96|80.00|43.21|x|x|x|x|
-|[fib](https://github.com/breuleux/ovld/tree/master/benchmarks/test_fib.py)|1.00|3.58|438.97|123.58|x|x|x|x|
-|[tweak](https://github.com/breuleux/ovld/tree/master/benchmarks/test_tweaknum.py)|1.00|2.59|x|x|x|x|x|x|
+|[trivial](https://github.com/breuleux/ovld/tree/master/benchmarks/test_trivial.py)|1.45|1.00|3.32|4.63|2.04|2.41|51.93|1.91|
+|[multer](https://github.com/breuleux/ovld/tree/master/benchmarks/test_multer.py)|1.13|1.00|11.05|4.53|8.31|2.19|46.74|7.32|
+|[add](https://github.com/breuleux/ovld/tree/master/benchmarks/test_add.py)|1.08|1.00|3.73|5.21|2.37|2.79|59.31|x|
+|[ast](https://github.com/breuleux/ovld/tree/master/benchmarks/test_ast.py)|1.00|1.08|23.14|3.09|1.68|1.91|28.39|1.66|
+|[calc](https://github.com/breuleux/ovld/tree/master/benchmarks/test_calc.py)|1.00|1.23|54.61|29.32|x|x|x|x|
+|[regexp](https://github.com/breuleux/ovld/tree/master/benchmarks/test_regexp.py)|1.00|1.87|19.18|x|x|x|x|x|
+|[fib](https://github.com/breuleux/ovld/tree/master/benchmarks/test_fib.py)|1.00|3.30|444.31|125.77|x|x|x|x|
+|[tweaknum](https://github.com/breuleux/ovld/tree/master/benchmarks/test_tweaknum.py)|1.00|2.09|x|x|x|x|x|x|

ovld-0.4.5/beary.py

@@ -0,0 +1,120 @@
+import timeit
+from dataclasses import dataclass
+
+from beartype import (
+    BeartypeConf,  # <-- this isn't your fault
+    beartype,
+)
+from beartype.claw import (
+    beartype_all,
+)  # <-- you didn't sign up for this
+from strongtyping.strong_typing import match_typing
+from typeguard import typechecked
+
+# from enforce import runtime_validation
+from ovld import ovld
+
+# from ovld.check import typecheck
+
+beartype_all(conf=BeartypeConf())
+# beartype_this_package()                                        # <-- raise exceptions in your code
+# beartype_all(conf=BeartypeConf(violation_type=UserWarning))
+
+
+@beartype
+def f_bear(x: int, y: int):
+    return x + y
+
+
+@ovld
+def f_ovld(x: int, y: int):
+    return x + y
+
+
+@ovld
+def f_ovld_D(x: int, y: int):
+    # breakpoint()
+    return x + y
+
+
+@match_typing
+def f_strong(x: int, y: int):
+    return x + y
+
+
+@typechecked
+def f_guard(x: int, y: int):
+    return x + y
+
+
+# @runtime_validation
+# def f_enforce(x: int, y: int):
+#     return x + y
+
+
+def f_custom(x: int, y: int):
+    assert isinstance(x, int) and isinstance(y, int)
+    return x + y
+
+
+class digdug(dict):
+    pass
+
+
+def adder(x, y):
+    return x + y
+
+
+didi = digdug({int: adder})
+didi2 = digdug({(int, int): adder})
+
+
+@dataclass
+class Poop:
+    didi: dict
+
+
+poo2 = Poop(didi2)
+
+
+def f_custom_2(x: int, y: int):
+    assert didi2[type(x), type(y)]
+    return x + y
+
+
+# def f_custom_2(x: int, y: int):
+#     func = didi[type(x)] and didi[type(y)]
+#     return func(x, y)
+
+
+class Gusto:
+    def __init__(self, didi):
+        self.didi = didi
+        self.__name__ = "gusto"
+
+    def __call__(self, x: int, y: int):
+        func = self.didi[type(x), type(y)]
+        return func(x, y)
+
+
+# f_bear(7, 8)
+# f_ovld("a", 3)
+# assert f_ovld(3, 4) == 7
+
+
+for fn in (
+    f_bear,
+    f_strong,
+    f_guard,
+    f_ovld_D,
+    f_ovld,
+    f_custom,
+    f_custom_2,
+    Gusto(didi2),
+    Gusto(didi2).__call__,
+):
+    timing = timeit.timeit(stmt=lambda: fn(3, 4), number=300000)
+    print(f"{fn.__name__:10}{1000 * timing:>10.3f}ms")
+
+breakpoint()
+f_ovld(4, 5)

{ovld-0.4.3 → ovld-0.4.5}/bench.py

@@ -4,6 +4,7 @@ from multimethod import multimethod
 from multipledispatch import dispatch
 from plum import dispatch as plum
 
+# from strongtyping_pyoverload import overload
 from ovld import ovld, recurse
 
 # OVLD
@@ -27,6 +28,7 @@ def smap(x: dict, y: dict):
 
 @ovld
 def smap(x: object, z: object):
+    1 / 0
     return x + z
 
 
@@ -157,6 +159,35 @@ def smap_pl(x: object, y: object):
     return x + y
 
 
+# # strongtyping
+
+
+# @overload
+# def smap_wh(x: list, y: list):
+#     """Three."""
+#     return [smap_wh(a, b) for a, b in zip(x, y)]
+
+
+# @overload
+# def smap_wh(x: tuple, y: tuple):
+#     return tuple(smap_wh(a, b) for a, b in zip(x, y))
+
+
+# @overload
+# def smap_wh(x: dict, y: dict):
+#     return {k: smap_wh(v, y[k]) for k, v in x.items()}
+
+
+# @overload
+# def smap_wh(x: object, y: object):
+#     return x + y
+
+
+# @overload
+# def smap_wh(x: str, y: str):
+#     return x + y
+
+
 ###
 
 
@@ -171,6 +202,7 @@ results = {
     "smap_ii": smap_ii(A, B),
     "smap_mh": smap_mh(A, B),
     "smap_c": smap_c(A, B),
+    # "smap_wh": smap_wh(A, B),
 }
 
 expected = results["smap"]
@@ -186,5 +218,6 @@ print("smap_md\t", 10 * timeit.timeit(lambda: smap_md(A, B), number=10000))
 print("smap_pl\t", 10 * timeit.timeit(lambda: smap_pl(A, B), number=10000))
 print("smap_ov\t", 10 * timeit.timeit(lambda: smap(A, B), number=10000))
 print("smap_c\t", 10 * timeit.timeit(lambda: smap_c(A, B), number=10000))
+# print("smap_wh\t", 10 * timeit.timeit(lambda: smap_wh(A, B), number=10000))
 print("smap_ii\t", 10 * timeit.timeit(lambda: smap_ii(A, B), number=10000))
 print("smap_mh\t", 10 * timeit.timeit(lambda: smap_mh(A, B), number=10000))

{ovld-0.4.3 → ovld-0.4.5}/benchmarks/test_calc.py

@@ -115,7 +115,7 @@ ops = {
 def calc_dict(expr):
     if isinstance(expr, tuple):
         return ops[expr[0]](*expr[1:])
-    elif isinstance(expr, (int, float)):
+    elif isinstance(expr, Number):
         return expr
 
 

{ovld-0.4.3 → ovld-0.4.5}/benchmarks/test_multer.py

@@ -148,7 +148,7 @@ def make_test(cls):
 
 
 test_multer_ovld = make_test(make_multer(ovld_dispatch))
-test_multer_ovld_recurse = make_test(OvldRecurseMulter)
+test_multer_recurse = make_test(OvldRecurseMulter)
 test_multer_plum = make_test(make_multer(plum_dispatch))
 test_multer_multimethod = make_test(make_multer(multimethod_dispatch))
 test_multer_singledispatch = make_test(SingleDispatchMulter)

ovld-0.4.5/benchmarks/test_regexp.py

@@ -0,0 +1,96 @@
+import re
+
+import pytest
+
+from ovld.dependent import Regexp
+
+from .common import ovld_dispatch, plum_dispatch
+
+###############################
+# multiple dispatch libraries #
+###############################
+
+
+def make_regexp(dispatch):
+    @dispatch
+    def regexp(x: Regexp[r"^a"]):
+        return "one"
+
+    @dispatch
+    def regexp(x: Regexp[r"^[bcd]"]):
+        return "two"
+
+    @dispatch
+    def regexp(x: Regexp[r"end$"]):
+        return "three"
+
+    return regexp
+
+
+##############
+# isinstance #
+##############
+
+
+def regexp_search(x):
+    if re.search(string=x, pattern=r"^a"):
+        return "one"
+    if re.search(string=x, pattern=r"^[bcd]"):
+        return "two"
+    if re.search(string=x, pattern=r"end$"):
+        return "three"
+
+
+re1 = re.compile(r"^a")
+re2 = re.compile(r"^[bcd]")
+re3 = re.compile(r"end$")
+
+
+def regexp_compiled(x):
+    if re1.search(x):
+        return "one"
+    if re2.search(x):
+        return "two"
+    if re3.search(x):
+        return "three"
+
+
+def regexp_compiled_nonexclusive(x):
+    r1 = bool(re1.search(x))
+    r2 = bool(re2.search(x))
+    r3 = bool(re3.search(x))
+    if r1:
+        return "one"
+    if r2:
+        return "two"
+    if r3:
+        return "three"
+
+
+####################
+# Test definitions #
+####################
+
+
+def make_test(fn):
+    @pytest.mark.benchmark(group="regexp")
+    def test(benchmark):
+        def run():
+            return [
+                fn("allo"),
+                fn("canada"),
+                fn("the end"),
+            ]
+
+        result = benchmark(run)
+        assert result == ["one", "two", "three"]
+
+    return test
+
+
+test_regexp_ovld = make_test(make_regexp(ovld_dispatch))
+test_regexp_plum = make_test(make_regexp(plum_dispatch))
+
+test_regexp_custom_search = make_test(regexp_search)
+test_regexp_custom_compiled = make_test(regexp_compiled)
+# test_regexp_custom_compiled_nx = make_test(regexp_compiled_nonexclusive)

ovld-0.4.5/benchmarks/test_tuple.py

@@ -0,0 +1,83 @@
+from typing import Literal
+
+import pytest
+
+from .common import (
+    multimethod_dispatch,
+    ovld_dispatch,
+    plum_dispatch,
+)
+
+###############################
+# multiple dispatch libraries #
+###############################
+
+
+def make_tup(dispatch):
+    @dispatch
+    def tup(t: tuple[()]):
+        return 0
+
+    @dispatch
+    def tup(t: tuple[int]):
+        return 1
+
+    @dispatch
+    def tup(t: tuple[Literal["x"]]):
+        return 2
+
+    @dispatch
+    def tup(t: tuple[int, str]):
+        return 3
+
+    @dispatch
+    def tup(t: tuple[tuple[str]]):
+        return 4
+
+    return tup
+
+
+#########
+# match #
+#########
+
+
+def tup_match(expr):
+    match expr:
+        case ():
+            return 0
+        case (int(),):
+            return 1
+        case (str(),):
+            return 2
+        case (int(), str()):
+            return 3
+        case ((str(),),):
+            return 4
+
+
+####################
+# Test definitions #
+####################
+
+
+def make_test(fn):
+    fn(())
+    fn = fn.__call__
+
+    def run():
+        return [fn(()), fn((1,)), fn(("x",)), fn((2, "y"))]
+
+    @pytest.mark.benchmark(group="tup")
+    def test(benchmark):
+        result = benchmark(run)
+        assert result == [0, 1, 2, 3]
+
+    return test
+
+
+test_tup_ovld = make_test(make_tup(ovld_dispatch))
+test_tup_plum = make_test(make_tup(plum_dispatch))
+test_tup_multimethod = make_test(make_tup(multimethod_dispatch))
+
+test_tup_custom_match = make_test(tup_match)

ovld-0.4.5/benchmarks/test_typechecking.py

@@ -0,0 +1,160 @@
+# from collections.abc import Collection
+# from dataclasses import dataclass
+# from itertools import product
+# from numbers import Number
+# from typing import Literal
+
+# import pytest
+# from beartype import beartype
+
+# try:
+#     from strongtyping.strong_typing import match_typing
+# except ImportError:
+#     match_typing = None
+# from typeguard import typechecked
+
+# from ovld import Ovld, ovld
+# from ovld.dependent import Dependent, Regexp
+# from ovld.types import Dataclass
+
+
+# @dataclass
+# class Point:
+#     x: int
+#     y: int
+
+
+# def ovld(fn):
+#     o = Ovld()
+#     o.register(fn)
+#     return o.dispatch
+
+
+# def typecheck_test(cases, checkers):
+#     def deco(fn):
+#         def make_test(chk_name, case_name, typecheck, params):
+#             group = f"{fn.__name__}_{case_name}"
+
+#             @pytest.mark.benchmark(group=group)
+#             def test(benchmark):
+#                 *args, out = params
+#                 tfn = typecheck(fn)
+#                 result = benchmark(tfn, *args)
+#                 assert result == out
+
+#             test.__name__ = f"test_{group}[{chk_name}]"
+#             globals()[test.__name__] = test
+
+#         for (case_name, case), (chk_name, chk) in product(
+#             cases.items(), checkers.items()
+#         ):
+#             if chk is not None:
+#                 make_test(chk_name, case_name, chk, case)
+
+#     return deco
+
+
+# @typecheck_test(
+#     cases=dict(normal=(10, 20, 200)),
+#     checkers=dict(
+#         ovld=ovld,
+#         beartype=beartype,
+#         typeguard=typechecked,
+#         strongtyping=match_typing,
+#     ),
+# )
+# def mul(x: int, y: int):
+#     return x * y
+
+
+# @typecheck_test(
+#     cases=dict(
+#         ints=(10, 20, 30),
+#         lists=([1], [2], [1, 2]),
+#     ),
+#     checkers=dict(
+#         ovld=ovld,
+#         beartype=beartype,
+#         typeguard=typechecked,
+#         strongtyping=match_typing,
+#     ),
+# )
+# def add(x: int | str | float | list, y: int | str | float | list):
+#     return x + y
+
+
+# @typecheck_test(
+#     cases=dict(
+#         normal=("http://google.com", "google.com"),
+#     ),
+#     checkers=dict(
+#         ovld=ovld,
+#         beartype=beartype,
+#         # typeguard=typechecked,
+#         # strongtyping=match_typing,
+#     ),
+# )
+# def urlregexp(url: Regexp[r"^http://.*"]):
+#     return url.split("://")[1]
+
+
+# @typecheck_test(
+#     cases=dict(
+#         normal=([1, 2, 3], 1),
+#     ),
+#     checkers=dict(
+#         ovld=ovld,
+#         beartype=beartype,
+#         typeguard=typechecked,
+#         strongtyping=match_typing,
+#     ),
+# )
+# def firstelem(elements: list[int]):
+#     return elements[0]
+
+
+# @typecheck_test(
+#     cases=dict(
+#         normal=(123, Point(1, 2), "low", "whatever"),
+#     ),
+#     checkers=dict(
+#         ovld=ovld,
+#         beartype=beartype,
+#         typeguard=typechecked,
+#         strongtyping=match_typing,
+#     ),
+# )
+# def misc(
+#     numero: Number, dc: Dataclass, method: Literal["low"] | Literal["high"]
+# ):
+#     return "whatever"
+
+
+# @typecheck_test(
+#     cases=dict(
+#         normal=(10, 11),
+#     ),
+#     checkers=dict(
+#         ovld=ovld,
+#         beartype=beartype,
+#         # typeguard=typechecked,
+#         # strongtyping=match_typing,
+#     ),
+# )
+# def positive(x: Dependent[int, lambda x: x > 0]):
+#     return x + 1
+
+
+# @typecheck_test(
+#     cases=dict(
+#         normal=((1, Point(2, 3), "blah"), ("blah", Point(2, 3), 1)),
+#     ),
+#     checkers=dict(
+#         ovld=ovld,
+#         beartype=beartype,
+#         typeguard=typechecked,
+#         strongtyping=match_typing,
+#     ),
+# )
+# def triple(xyz: tuple[Number, Dataclass, Collection]):
+#     return tuple(reversed(xyz))

ovld-0.4.5/coco.py

@@ -0,0 +1,79 @@
+from typing import Callable
+
+from ovld.core import ovld
+
+# from plum import dispatch as ovld
+# from multimethod import multimethod as ovld
+
+
+class Animal:
+    pass
+
+
+class Mammal(Animal):
+    pass
+
+
+class Cat(Mammal):
+    pass
+
+
+@ovld
+def f(t: Callable[[Mammal], Mammal]):
+    return 1
+
+
+@ovld
+def f(t: Callable[[Mammal, Mammal], Mammal]):
+    return 2
+
+
+def f1(x: Mammal, y: Mammal) -> Mammal:
+    return "X"
+
+
+def f2(x: Animal, y: Animal) -> Mammal:
+    return "X"
+
+
+print(f(f1))
+print(f(f2))
+
+
+# @ovld
+# def f(t: tuple[()]):
+#     return 0
+
+# @ovld
+# def f(t: tuple[int]):
+#     return 1
+
+# @ovld
+# def f(t: tuple[str]):
+#     return 2
+
+# @ovld
+# def f(t: tuple[int, str]):
+#     return 3
+
+# assert f(()) == 0
+# assert f((1,)) == 1
+# assert f(("x",)) == 2
+# assert f((2, "y")) == 3
+
+
+# @ovld
+# def f(d: Sequence[int]):
+#     return 0
+
+
+# @ovld
+# def f(d: Sequence[str]):
+#     return 1
+
+
+# print(f([1]))
+# print(f(["x"]))
+# print(f([1, "x"]))
+# print(f(["x", "y", "z", 1]))
+# print(f([]))