More thorough handling of Any

Author: breuleux

src/ovld/mro.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass
 from enum import Enum
 from graphlib import TopologicalSorter
-from typing import Annotated, get_args, get_origin
+from typing import Annotated, Any, get_args, get_origin
 
 from .utils import UnionTypes, is_dependent
 
@@ -52,6 +52,10 @@ def typeorder(t1, t2):
     """
     if t1 == t2:
         return Order.SAME
+    if t1 is Any:
+        return Order.MORE
+    if t2 is Any:
+        return Order.LESS
 
     if (
         hasattr(t1, "__type_order__")
@@ -80,8 +84,12 @@ def typeorder(t1, t2):
             return typeorder(t1, t2)
 
     if o1 is Annotated:
+        if t2 is Annotated:
+            return Order.LESS
         return typeorder(get_args(t1)[0], t2)
     if o2 is Annotated:
+        if t1 is Annotated:
+            return Order.MORE
         return typeorder(t1, get_args(t2)[0])
 
     if o2 and not o1:
@@ -90,8 +98,8 @@ def typeorder(t1, t2):
     if o1:
         if not o2:
             order = typeorder(o1, t2)
-            if order is order.SAME:
-                order = order.LESS
+            if order is Order.SAME:
+                order = Order.LESS
             return order
 
         if (order := typeorder(o1, o2)) is not Order.SAME:
@@ -110,6 +118,9 @@ def typeorder(t1, t2):
         ords = [typeorder(a1, a2) for a1, a2 in zip(args1, args2)]
         return Order.merge(ords)
 
+    if not isinstance(t1, type) or not isinstance(t2, type):  # pragma: no cover
+        return Order.SAME
+
     sx = issubclass(t1, t2)
     sy = issubclass(t2, t1)
     if sx and sy:  # pragma: no cover
@@ -125,7 +136,7 @@ def typeorder(t1, t2):
 
 def subclasscheck(t1, t2):
     """Check whether t1 is a "subclass" of t2."""
-    if t1 == t2:
+    if t1 == t2 or t2 is Any:
         return True
 
     if (

src/ovld/utils.py

@@ -199,6 +199,7 @@ def get_args(tp):
     type(list[object]).__instancecheck__,
     ABCMeta.__instancecheck__,
     type(typing.Protocol).__instancecheck__,
+    type(typing.Any).__instancecheck__,
 }
 
 

tests/test_mro.py

@@ -1,5 +1,8 @@
+import sys
 from dataclasses import dataclass
-from typing import Annotated, Iterable, Mapping
+from typing import Annotated, Any, Iterable, Mapping
+
+import pytest
 
 from ovld.dependent import Dependent, Regexp
 from ovld.mro import Order, subclasscheck, typeorder
@@ -147,13 +150,29 @@ def test_subclasscheck_anntype():
     assert not subclasscheck(type[int], type[Annotated[int, "hello"]])
 
 
+@pytest.mark.skipif(
+    sys.version_info < (3, 12), reason="Python 3.11 is more strict on Annotated"
+)
+def test_subclasscheck_anntype_any():
+    assert subclasscheck(type[Annotated[int, "hello"]], type[Annotated[Any, "hello"]])
+    assert subclasscheck(type[Annotated[123, "hello"]], type[Annotated[Any, "hello"]])
+
+
+def test_typeorder_any():
+    assert typeorder(int, Any) is Order.LESS
+    assert typeorder(Any, int) is Order.MORE
+    assert typeorder(Any, Any) is Order.SAME
+
+
 @dataclass(frozen=True)
 class Anno:
     name: str
     annotation_priority: int = 0
 
 
 def test_typeorder_anntype():
+    assert typeorder(type[Annotated], type[Annotated[int, "hello"]]) is Order.MORE
+    assert typeorder(type[Annotated[int, "hello"]], type[Annotated]) is Order.LESS
     assert (
         typeorder(type[Annotated[int, "hello"]], type[Annotated[int, "world"]]) is Order.SAME
     )

tests/test_ovld.py

@@ -3,7 +3,7 @@
 import sys
 import typing
 from dataclasses import dataclass
-from typing import Annotated
+from typing import Annotated, Any
 
 import pytest
 
@@ -1297,6 +1297,23 @@ def f(t: object):
     assert f(Annotated[str, 1, 2, 3, "world"]) == "world"
 
 
+@pytest.mark.skipif(
+    sys.version_info < (3, 12), reason="Python 3.11 is more strict on Annotated"
+)
+def test_annotated_type_argument_any():
+    @ovld
+    def f(t: type[Annotated[Any, "hello"]]):
+        return "hello"
+
+    @ovld
+    def f(t: object):
+        return False
+
+    assert f(Annotated[str, "hello"]) == "hello"
+    assert f(Annotated[123, "hello", "X"]) == "hello"
+    assert f(Annotated[str, 1, 2, 3, "hello"]) == "hello"
+
+
 @dataclass(frozen=True)
 class Anno:
     name: str