ovld 0.4.2__tar.gz → 0.4.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ovld
-Version: 0.4.2
+Version: 0.4.3
 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.2 → ovld-0.4.3}/pyproject.toml

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

{ovld-0.4.2 → ovld-0.4.3}/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:
 

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

@@ -15,6 +15,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 +71,9 @@ __all__ = [
     "Intersection",
     "StrictSubclass",
     "class_check",
+    "subclasscheck",
+    "typeorder",
+    "TypeRelationship",
     "parametrized_class_check",
     "keyword_decorator",
     "call_next",

{ovld-0.4.2 → ovld-0.4.3}/src/ovld/dependent.py

@@ -7,7 +7,6 @@ from typing import TYPE_CHECKING, Any, Mapping, TypeVar, Union
 from .types import (
     Intersection,
     Order,
-    TypeRelationship,
     normalize_type,
     subclasscheck,
     typeorder,
@@ -67,26 +66,34 @@ class DependentType:
     def codegen(self):
         return CodeGen("{this}.check({arg})", {"this": self})
 
-    def __typeorder__(self, other):
+    def __type_order__(self, other):
         if isinstance(other, DependentType):
             order = typeorder(self.bound, other.bound)
             if order is Order.SAME:
                 # It isn't fully deterministic which of these will be called
                 # because of set ordering between the types we compare
                 if self < other:  # pragma: no cover
-                    return TypeRelationship(Order.LESS, matches=False)
+                    return Order.LESS
                 elif other < self:  # pragma: no cover
-                    return TypeRelationship(Order.MORE, matches=False)
+                    return Order.MORE
                 else:
-                    return TypeRelationship(Order.NONE, matches=False)
+                    return Order.NONE
             else:  # pragma: no cover
-                return TypeRelationship(order, matches=False)
-        elif (matches := subclasscheck(other, self.bound)) or subclasscheck(
+                return order
+        elif subclasscheck(other, self.bound) or subclasscheck(
             self.bound, other
         ):
-            return TypeRelationship(Order.LESS, matches=matches)
+            return Order.LESS
         else:
-            return TypeRelationship(Order.NONE, matches=False)
+            return Order.NONE
+
+    def __is_supertype__(self, other):
+        if isinstance(other, DependentType):
+            return False
+        elif subclasscheck(other, self.bound):
+            return True
+        else:
+            return False
 
     def __lt__(self, other):
         return False

{ovld-0.4.2 → ovld-0.4.3}/src/ovld/mro.py

@@ -22,7 +22,8 @@ class Order(Enum):
 @dataclass
 class TypeRelationship:
     order: Order
-    matches: bool = None
+    supertype: bool = NotImplemented
+    subtype: bool = NotImplemented
 
 
 def _issubclass(t1, t2):
@@ -48,19 +49,16 @@ def typeorder(t1, t2):
     if t1 == t2:
         return Order.SAME
 
-    t1 = getattr(t1, "__proxy_for__", t1)
-    t2 = getattr(t2, "__proxy_for__", t2)
-
     if (
-        hasattr(t1, "__typeorder__")
-        and (result := t1.__typeorder__(t2)) is not NotImplemented
+        hasattr(t1, "__type_order__")
+        and (result := t1.__type_order__(t2)) is not NotImplemented
     ):
-        return result.order
+        return result
     elif (
-        hasattr(t2, "__typeorder__")
-        and (result := t2.__typeorder__(t1)) is not NotImplemented
+        hasattr(t2, "__type_order__")
+        and (result := t2.__type_order__(t1)) is not NotImplemented
     ):
-        return result.order.opposite()
+        return result.opposite()
 
     o1 = getattr(t1, "__origin__", None)
     o2 = getattr(t2, "__origin__", None)
@@ -135,14 +133,17 @@ def subclasscheck(t1, t2):
     if t1 == t2:
         return True
 
-    t1 = getattr(t1, "__proxy_for__", t1)
-    t2 = getattr(t2, "__proxy_for__", t2)
+    if (
+        hasattr(t2, "__is_supertype__")
+        and (result := t2.__is_supertype__(t1)) is not NotImplemented
+    ):
+        return result
 
     if (
-        hasattr(t2, "__typeorder__")
-        and (result := t2.__typeorder__(t1)) is not NotImplemented
+        hasattr(t1, "__is_subtype__")
+        and (result := t1.__is_subtype__(t2)) is not NotImplemented
     ):
-        return result.matches
+        return result
 
     o1 = getattr(t1, "__origin__", None)
     o2 = getattr(t2, "__origin__", None)

{ovld-0.4.2 → ovld-0.4.3}/src/ovld/types.py

@@ -61,19 +61,31 @@ class MetaMC(type):
     def __init__(cls, name, order):
         pass
 
-    def __typeorder__(cls, other):
-        order = cls.order(other)
-        if isinstance(order, bool):
-            return NotImplemented
+    def __type_order__(cls, other):
+        results = cls.order(other)
+        if isinstance(results, TypeRelationship):
+            return results.order
         else:
-            return order
+            return NotImplemented
+
+    def __is_supertype__(cls, other):
+        results = cls.order(other)
+        if isinstance(results, bool):
+            return results
+        elif isinstance(results, TypeRelationship):
+            return results.supertype
+        else:  # pragma: no cover
+            return NotImplemented
+
+    def __is_subtype__(cls, other):
+        results = cls.order(other)
+        if isinstance(results, TypeRelationship):
+            return results.subtype
+        else:  # pragma: no cover
+            return NotImplemented
 
     def __subclasscheck__(cls, sub):
-        result = cls.order(sub)
-        if isinstance(result, TypeRelationship):
-            return result.order in (Order.MORE, Order.SAME)
-        else:
-            return result
+        return cls.__is_supertype__(sub)
 
 
 def class_check(condition):
@@ -164,7 +176,7 @@ def Exactly(cls, base_cls):
     """Match the class but not its subclasses."""
     return TypeRelationship(
         order=Order.LESS if cls is base_cls else typeorder(base_cls, cls),
-        matches=cls is base_cls,
+        supertype=cls is base_cls,
     )
 
 
@@ -184,11 +196,11 @@ def Intersection(cls, *classes):
     matches = all(subclasscheck(cls, t) for t in classes)
     compare = [x for t in classes if (x := typeorder(t, cls)) is not Order.NONE]
     if not compare:
-        return TypeRelationship(Order.NONE, matches=matches)
+        return TypeRelationship(Order.NONE, supertype=matches)
     elif any(x is Order.LESS or x is Order.SAME for x in compare):
-        return TypeRelationship(Order.LESS, matches=matches)
+        return TypeRelationship(Order.LESS, supertype=matches)
     else:
-        return TypeRelationship(Order.MORE, matches=matches)
+        return TypeRelationship(Order.MORE, supertype=matches)
 
 
 @parametrized_class_check

ovld-0.4.3/src/ovld/version.py

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

ovld-0.4.3/tests/test_mro.py

@@ -0,0 +1,112 @@
+try:
+    from types import UnionType
+except ImportError:  # pragma: no cover
+    UnionType = None
+
+import sys
+from typing import Union
+
+from ovld.dependent import Dependent
+from ovld.mro import Order, subclasscheck, typeorder
+
+
+def identity(x):
+    return x
+
+
+class A:
+    pass
+
+
+class B(A):
+    pass
+
+
+class Prox:
+    _cls = object
+
+    def __class_getitem__(cls, other):
+        return type(f"Prox[{other.__name__}]", (Prox,), {"_cls": other})
+
+    @classmethod
+    def __is_supertype__(cls, other):
+        return subclasscheck(other, cls._cls)
+
+    @classmethod
+    def __is_subtype__(cls, other):
+        return subclasscheck(cls._cls, other)
+
+    @classmethod
+    def __type_order__(cls, other):
+        return typeorder(cls._cls, other)
+
+
+def test_subclasscheck():
+    assert subclasscheck(B, A)
+    assert not subclasscheck(A, B)
+    assert subclasscheck(A, A)
+    assert subclasscheck(A, object)
+    assert subclasscheck(A, Union[A, int])
+    assert subclasscheck(int, Union[A, int])
+
+
+def test_subclasscheck_generic():
+    assert subclasscheck(list[int], list[int])
+    assert subclasscheck(list[int], list[object])
+    assert not subclasscheck(list[object], list[int])
+
+
+def test_subclasscheck_type():
+    assert subclasscheck(type[int], type[object])
+
+
+def test_subclasscheck_type_union():
+    if sys.version_info >= (3, 10):
+        assert subclasscheck(type[int | str], type[UnionType])
+    assert subclasscheck(type[Union[int, str]], type[Union])
+    assert subclasscheck(type[Union], object)
+    assert not subclasscheck(object, type[Union])
+
+
+def test_typeorder_type_union():
+    if sys.version_info >= (3, 10):
+        assert typeorder(type[int | str], type[UnionType]) is Order.LESS
+    assert typeorder(type[Union[int, str]], type[Union]) is Order.LESS
+    assert typeorder(object, type[Union]) is Order.MORE
+
+
+def test_subclasscheck_dependent():
+    assert subclasscheck(B, Dependent[A, identity])
+    assert not subclasscheck(
+        Dependent[int, identity], Dependent[float, identity]
+    )
+
+
+def test_typeorder_dependent():
+    assert typeorder(Dependent[int, identity], float) is Order.NONE
+    assert (
+        typeorder(Dependent[int, identity], Dependent[A, identity])
+        is Order.NONE
+    )
+    assert (
+        typeorder(Dependent[int, identity], Dependent[float, identity])
+        is Order.NONE
+    )
+
+
+def test_subclasscheck_proxy():
+    assert subclasscheck(Prox[int], int)
+    assert subclasscheck(int, Prox[int])
+    assert subclasscheck(Prox[int], Prox)
+    assert not subclasscheck(Prox, Prox[int])
+
+    assert subclasscheck(Prox[B], A)
+    assert not subclasscheck(Prox[A], B)
+    assert subclasscheck(B, Prox[A])
+    assert not subclasscheck(A, Prox[B])
+    assert subclasscheck(Prox[B], Prox[A])
+
+    assert typeorder(Prox[int], int) is Order.SAME
+    assert typeorder(int, Prox[int]) is Order.SAME
+    assert typeorder(Prox[int], Prox) is Order.LESS
+    assert typeorder(Prox, Prox[int]) is Order.MORE

{ovld-0.4.2 → ovld-0.4.3}/todo.q

@@ -13,6 +13,9 @@
 * Optimize the itertools.product in mro
 * Context variable to turn off code generation
 * Add second priority level corresponding to definition order
+* Support `tuple[t1, t2, ...]
+* Support `TypedDict
+* Support `dict[kt, vt], `list[et], etc.
 
 
 = DONE

{ovld-0.4.2 → ovld-0.4.3}/uv.lock

@@ -330,7 +330,7 @@ wheels = [
 
 [[package]]
 name = "ovld"
-version = "0.4.1"
+version = "0.4.2"
 source = { editable = "." }
 
 [package.dev-dependencies]

ovld-0.4.2/src/ovld/version.py

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

ovld-0.4.2/tests/test_mro.py

@@ -1,51 +0,0 @@
-try:
-    from types import UnionType
-except ImportError:  # pragma: no cover
-    UnionType = None
-
-import sys
-from typing import Union
-
-from ovld.mro import Order, subclasscheck, typeorder
-
-
-class A:
-    pass
-
-
-class B(A):
-    pass
-
-
-def test_subclasscheck():
-    assert subclasscheck(B, A)
-    assert not subclasscheck(A, B)
-    assert subclasscheck(A, A)
-    assert subclasscheck(A, object)
-    assert subclasscheck(A, Union[A, int])
-    assert subclasscheck(int, Union[A, int])
-
-
-def test_subclasscheck_generic():
-    assert subclasscheck(list[int], list[int])
-    assert subclasscheck(list[int], list[object])
-    assert not subclasscheck(list[object], list[int])
-
-
-def test_subclasscheck_type():
-    assert subclasscheck(type[int], type[object])
-
-
-def test_subclasscheck_type_union():
-    if sys.version_info >= (3, 10):
-        assert subclasscheck(type[int | str], type[UnionType])
-    assert subclasscheck(type[Union[int, str]], type[Union])
-    assert subclasscheck(type[Union], object)
-    assert not subclasscheck(object, type[Union])
-
-
-def test_typeorder_type_union():
-    if sys.version_info >= (3, 10):
-        assert typeorder(type[int | str], type[UnionType]) is Order.LESS
-    assert typeorder(type[Union[int, str]], type[Union]) is Order.LESS
-    assert typeorder(object, type[Union]) is Order.MORE