ovld 0.4.2__tar.gz → 0.4.4__tar.gz

{ovld-0.4.2 → ovld-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ovld
-Version: 0.4.2
+Version: 0.4.4
 Summary: Overloading Python functions
 Project-URL: Homepage, https://ovld.readthedocs.io/en/latest/
 Project-URL: Documentation, https://ovld.readthedocs.io/en/latest/

ovld-0.4.4/beary.py

@@ -0,0 +1,30 @@
+import timeit
+from typing import Literal
+from beartype import BeartypeConf                              # <-- this isn't your fault
+from beartype.claw import beartype_all, beartype_this_package  # <-- you didn't sign up for this
+from beartype import beartype
+from ovld import ovld
+from strongtyping.strong_typing import match_typing
+
+beartype_all(conf=BeartypeConf())
+# beartype_this_package()                                        # <-- raise exceptions in your code
+# beartype_all(conf=BeartypeConf(violation_type=UserWarning))
+
+@match_typing
+def f1(x: int, y: int):
+    return x + y
+
+
+@ovld
+def f2(x: int, y: int):
+    return x + y
+
+
+def f3(x: int, y: int):
+    assert isinstance(x, int) and isinstance(y, int)
+    return x + y
+
+
+print(timeit.timeit(stmt=lambda: f1(3, 4), number=100000))
+print(timeit.timeit(stmt=lambda: f2(3, 4), number=100000))
+print(timeit.timeit(stmt=lambda: f3(3, 4), number=100000))

ovld-0.4.4/benchmarks/test_tuple.py

@@ -0,0 +1,80 @@
+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):
+    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.4/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([]))

ovld-0.4.4/didi.py

@@ -0,0 +1,60 @@
+from ovld.core import ovld
+from ovld.dependent import Equals
+from ovld.types import Dataclass, Exactly, HasMethod
+
+# U = Union[str, int]
+# U = str | Equals[0]
+# print(isinstance("ah", U))
+# print(isinstance(0, U))
+# print(is_dependent(U))
+
+
+@ovld
+def f(x: str | Equals[0]):
+    return x
+
+
+breakpoint()
+print(f(0))
+print(f(1))
+print(f("what"))
+
+
+print(Equals[4].__instancecheck__.__func__)
+print(HasMethod["__len__"].__instancecheck__.__func__)
+print(Exactly[int].__instancecheck__.__func__)
+print(Dataclass.__instancecheck__.__func__)
+
+
+print(isinstance(4, Equals[4]))
+print(isinstance(4, Equals[4.0]))
+print(isinstance([1], HasMethod["__len__"]))
+print(issubclass(type([1]), HasMethod["__len__"]))
+
+
+# from multimethod import multimethod as dispatch
+# from plum import dispatch
+# from runtype import multidispatch as dispatch
+
+# from ovld import ovld as dispatch
+
+
+# @dispatch
+# def f(x: type[int]):
+#     return "ah"
+
+
+# @dispatch
+# def f(x: type[object]):
+#     return "something else"
+
+
+# @dispatch
+# def f(x: type[dict[str, object]]):
+#     return ("didi", x)
+
+
+# print(f(int))
+# print(f(str))
+# print(f(dict[str, int]))
+# print(f(dict[int, int]))

{ovld-0.4.2 → ovld-0.4.4}/docs/types.md

@@ -129,6 +129,16 @@ f(123)  # ERROR
 ```
 
 
+## All
+
+`ovld.types.All` is the bottom/empty/void type. You can use it as a wildcard in a contravariant setting, e.g. all 2-argument functions are instances of `Callable[[All, All], Any]` because the arguments are contravariant.
+
+
+## Whatever
+
+`ovld.types.Whatever` acts like a superclass and a subclass of everything, as a convenience (a bit like saying "there's no type here"). It'll match anything anywhere, so you can write e.g. `Callable[[Whatever, Whatever], Whatever]` to match any function of two arguments, whereas otherwise you would need to use `Any` for the return type and `All` for the parameter types.
+
+
 ## Defining new types
 
 With the `@parametrized_class_check` decorator, you can define a new type or protocol extremely easily. For example, here is how to define `HasMethod` yourself:

{ovld-0.4.2 → ovld-0.4.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ovld"
-version = "0.4.2"
+version = "0.4.4"
 description = "Overloading Python functions"
 authors = [
     { name = "Olivier Breuleux", email = "breuleux@gmail.com" }

{ovld-0.4.2 → ovld-0.4.4}/reddit.md

@@ -1,6 +1,6 @@
 ## What My Project Does
 
-`ovld` implements multiple dispatch in Python. This lets you define multiple versions of the same function with different type signatures.
+[ovld](https://github.com/breuleux/ovld) implements multiple dispatch in Python. This lets you define multiple versions of the same function with different type signatures.
 
 For example:
 
@@ -35,6 +35,7 @@ Ovld is pretty generally applicable: multiple dispatch is a central feature of s
 ## Features
 
 * Wide range of supported annotations: normal types, protocols, Union, Literal, [custom types](https://ovld.readthedocs.io/en/latest/types/#defining-new-types) such as HasMethod, Intersection and arbitrary user-defined types.
+* Intersection type, so you can write types like `Shape[Any, 3] & Int8 & OnGPU`
 * Support for [dependent types](https://ovld.readthedocs.io/en/latest/dependent/), by which I mean "types" that depend on the values of the arguments. For example you can easily implement a `Regexp[regex]` type that matches string arguments based on regular expressions, or a type that only matches 2x2 torch.Tensor with int8 dtype.
 * Dispatch on keyword arguments (with a few limitations).
 * Define numeric priority levels for disambiguation.

{ovld-0.4.2 → ovld-0.4.4}/src/ovld/__init__.py

@@ -1,5 +1,6 @@
 from typing import TYPE_CHECKING
 
+from . import abc  # noqa: F401
 from .core import (
     Ovld,
     OvldBase,
@@ -15,6 +16,11 @@ from .dependent import (
     ParametrizedDependentType,
     dependent_check,
 )
+from .mro import (
+    TypeRelationship,
+    subclasscheck,
+    typeorder,
+)
 from .recode import call_next, recurse
 from .typemap import (
     MultiTypeMap,
@@ -66,6 +72,9 @@ __all__ = [
     "Intersection",
     "StrictSubclass",
     "class_check",
+    "subclasscheck",
+    "typeorder",
+    "TypeRelationship",
     "parametrized_class_check",
     "keyword_decorator",
     "call_next",

ovld-0.4.4/src/ovld/abc.py

@@ -0,0 +1,48 @@
+import typing
+from collections.abc import Callable, Collection, Mapping, Sequence
+
+from .dependent import Callable as OvldCallable
+from .dependent import (
+    CollectionFastCheck,
+    Equals,
+    MappingFastCheck,
+    ProductType,
+    SequenceFastCheck,
+)
+from .types import normalize_type
+
+
+@normalize_type.register_generic(typing.Literal)
+def _(self, t, fn):
+    return Equals[t.__args__]
+
+
+@normalize_type.register_generic(tuple)
+def _(self, t, fn):
+    args = tuple(self(arg, fn) for arg in t.__args__)
+    return ProductType[args]
+
+
+@normalize_type.register_generic(Sequence)
+def _(self, t, fn):
+    args = tuple(self(arg, fn) for arg in t.__args__)
+    return SequenceFastCheck[args]
+
+
+@normalize_type.register_generic(Collection)
+def _(self, t, fn):
+    args = tuple(self(arg, fn) for arg in t.__args__)
+    return CollectionFastCheck[args]
+
+
+@normalize_type.register_generic(Mapping)
+def _(self, t, fn):
+    args = tuple(self(arg, fn) for arg in t.__args__)
+    return MappingFastCheck[args]
+
+
+@normalize_type.register_generic(Callable)
+def _(self, t, fn):
+    *at, rt = t.__args__
+    at = tuple(self(arg, fn) for arg in at)
+    return OvldCallable[at, self(rt, fn)]

{ovld-0.4.2 → ovld-0.4.4}/src/ovld/core.py

@@ -16,9 +16,9 @@ from .recode import (
     generate_dispatch,
     rename_function,
 )
-from .typemap import MultiTypeMap, is_type_of_type
-from .types import normalize_type
-from .utils import UsageError, keyword_decorator
+from .typemap import MultiTypeMap
+from .types import clsstring, normalize_type
+from .utils import UsageError, keyword_decorator, subtler_type
 
 _current_id = itertools.count()
 
@@ -80,6 +80,7 @@ class Arginfo:
 @dataclass(frozen=True)
 class Signature:
     types: tuple
+    return_type: type
     req_pos: int
     max_pos: int
     req_names: frozenset
@@ -139,6 +140,7 @@ class Signature:
 
         return cls(
             types=tuple(typelist),
+            return_type=normalize_type(sig.return_annotation, fn),
             req_pos=req_pos,
             max_pos=max_pos,
             req_names=frozenset(req_names),
@@ -149,28 +151,16 @@ class Signature:
         )
 
 
-def clsstring(cls):
-    if cls is object:
-        return "*"
-    elif isinstance(cls, tuple):
+def typemap_entry_string(cls):
+    if isinstance(cls, tuple):
         key, typ = cls
         return f"{key}: {clsstring(typ)}"
-    elif is_type_of_type(cls):
-        arg = clsstring(cls.__args__[0])
-        return f"type[{arg}]"
-    elif hasattr(cls, "__origin__"):
-        if cls.__origin__ is typing.Union:
-            return "|".join(map(clsstring, cls.__args__))
-        else:
-            return repr(cls)
-    elif hasattr(cls, "__name__"):
-        return cls.__name__
     else:
-        return repr(cls)
+        return clsstring(cls)
 
 
 def sigstring(types):
-    return ", ".join(map(clsstring, types))
+    return ", ".join(map(typemap_entry_string, types))
 
 
 class ArgumentAnalyzer:
@@ -277,9 +267,7 @@ class ArgumentAnalyzer:
         )
 
     def lookup_for(self, key):
-        return (
-            "self.map.transform" if key in self.complex_transforms else "type"
-        )
+        return subtler_type if key in self.complex_transforms else type
 
 
 class _Ovld:
@@ -473,7 +461,7 @@ class _Ovld:
     @_compile_first
     def resolve(self, *args):
         """Find the correct method to call for the given arguments."""
-        return self.map[tuple(map(self.map.transform, args))]
+        return self.map[tuple(map(subtler_type, args))]
 
     def register_signature(self, sig, orig_fn):
         """Register a function for the given signature."""
@@ -577,7 +565,7 @@ class _Ovld:
 
         This should be replaced by an auto-generated function.
         """
-        key = tuple(map(self.map.transform, args))
+        key = tuple(map(subtler_type, args))
         method = self.map[key]
         return method(*args)
 
@@ -586,7 +574,7 @@ class _Ovld:
     def next(self, *args):
         """Call the next matching method after the caller, in terms of priority or specificity."""
         fr = sys._getframe(1)
-        key = (fr.f_code, *map(self.map.transform, args))
+        key = (fr.f_code, *map(subtler_type, args))
         method = self.map[key]
         return method(*args)
 
@@ -631,20 +619,20 @@ class OvldCall:
     def next(self, *args):
         """Call the next matching method after the caller, in terms of priority or specificity."""
         fr = sys._getframe(1)
-        key = (fr.f_code, *map(self.map.transform, args))
+        key = (fr.f_code, *map(subtler_type, args))
         method = self.map[key]
         return method(self.obj, *args)
 
     def resolve(self, *args):
         """Find the right method to call for the given arguments."""
-        return self.map[tuple(map(self.map.transform, args))].__get__(self.obj)
+        return self.map[tuple(map(subtler_type, args))].__get__(self.obj)
 
     def __call__(self, *args):  # pragma: no cover
         """Call this overloaded function.
 
         This should be replaced by an auto-generated function.
         """
-        key = tuple(map(self.map.transform, args))
+        key = tuple(map(subtler_type, args))
         method = self.map[key]
         return method(self.obj, *args)