ovld 0.5.7__tar.gz → 0.5.9__tar.gz

{ovld-0.5.7 → ovld-0.5.9}/.github/workflows/python-package.yml

@@ -45,6 +45,8 @@ jobs:
           coverage: false
         - python: '3.13'
           coverage: true
+        - python: '3.14'
+          coverage: false
     steps:
     - name: Check out the code
       uses: actions/checkout@v3

{ovld-0.5.7 → ovld-0.5.9}/PKG-INFO

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

{ovld-0.5.7 → ovld-0.5.9}/pyproject.toml

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

{ovld-0.5.7 → ovld-0.5.9}/src/ovld/medley.py

@@ -164,7 +164,7 @@ class medley_cls_dict(dict):
         super().__setitem__(attr, value)
 
     def __setitem__(self, attr, value):
-        if attr == "__annotations__":
+        if attr == "__annotations__" or attr == "__annotate_func__":
             self.set_direct(attr, value)
             return
 
@@ -365,6 +365,7 @@ def meld_classes(classes):
     merged = medley_cls_dict(medleys)
     merged.set_direct("_ovld_codegen_fields", tuple(cg_fields))
     merged.set_direct("_ovld_medleys", tuple(medleys))
+    merged.set_direct("__annotations__", {name: t for name, t, f in dc_fields})
 
     if "__qualname__" in merged._combiners:
         del merged._combiners["__qualname__"]

{ovld-0.5.7 → ovld-0.5.9}/src/ovld/mro.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass
 from enum import Enum
 from graphlib import TopologicalSorter
-from typing import 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__")
@@ -67,14 +71,35 @@ def typeorder(t1, t2):
     o1 = get_origin(t1)
     o2 = get_origin(t2)
 
+    if o1 is Annotated and o2 is Annotated:
+        t1, *a1 = get_args(t1)
+        t2, *a2 = get_args(t2)
+        p1 = max([getattr(ann, "annotation_priority", 0) for ann in a1], default=0)
+        p2 = max([getattr(ann, "annotation_priority", 0) for ann in a2], default=0)
+        if p1 < p2:
+            return Order.MORE
+        elif p2 < p1:
+            return Order.LESS
+        else:
+            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:
         return typeorder(t2, t1).opposite()
 
     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:
@@ -93,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
@@ -106,9 +134,18 @@ def typeorder(t1, t2):
         return Order.NONE
 
 
+def _find_ann(main, others):
+    if main in others:
+        return True
+    elif isinstance(main, type):
+        return any(isinstance(x, main) for x in others)
+    else:
+        return False
+
+
 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 (
@@ -134,12 +171,20 @@ def subclasscheck(t1, t2):
     o1 = get_origin(t1)
     o2 = get_origin(t2)
 
+    if o1 is Annotated and o2 is Annotated:
+        t1, *a1 = get_args(t1)
+        t2, *a2 = get_args(t2)
+        return subclasscheck(t1, t2) and any(_find_ann(main, a1) for main in a2)
+
+    if o1 is Annotated:
+        return t2 is Annotated
+
     if not isinstance(o1, type):
         o1 = None
     if not isinstance(o2, type):
         o2 = None
 
-    if o1 or o2:
+    if (o1 or o2) and o2 not in UnionTypes:
         o1 = o1 or t1
         o2 = o2 or t2
         if isinstance(o1, type) and isinstance(o2, type) and issubclass(o1, o2):

{ovld-0.5.7 → ovld-0.5.9}/src/ovld/utils.py

@@ -199,6 +199,7 @@ _standard_instancechecks = {
     type(list[object]).__instancecheck__,
     ABCMeta.__instancecheck__,
     type(typing.Protocol).__instancecheck__,
+    type(typing.Any).__instancecheck__,
 }
 
 

ovld-0.5.9/src/ovld/version.py

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

{ovld-0.5.7 → ovld-0.5.9}/tests/test_medley.py

@@ -530,3 +530,14 @@ def test_absent():
         lx.two
     with pytest.raises(AttributeError, match="no attribute 'three'"):
         lx.three
+
+
+def test_default_factory_inheritance():
+    class Lost(Medley):
+        xs: list = field(default_factory=list)
+
+    class Lust(Lost):
+        pass
+
+    lu = Lust()
+    assert lu.xs == []

{ovld-0.5.7 → ovld-0.5.9}/tests/test_mro.py

@@ -1,5 +1,8 @@
+import sys
 from dataclasses import dataclass
-from typing import Iterable, Mapping
+from typing import Annotated, Any, Iterable, Mapping
+
+import pytest
 
 from ovld.dependent import Dependent, Regexp
 from ovld.mro import Order, subclasscheck, typeorder
@@ -132,6 +135,66 @@ def test_subclasscheck_type():
     assert subclasscheck(type[int], type[object])
 
 
+def test_subclasscheck_anntype():
+    assert subclasscheck(type[Annotated[int, "hello"]], type[Annotated])
+    assert subclasscheck(type[Annotated[int, "hello"]], type[Annotated[object, "hello"]])
+    assert subclasscheck(
+        type[Annotated[int, "hello"]], type[Annotated[object, "hello", "world"]]
+    )
+    assert subclasscheck(
+        type[Annotated[int, "hello", "world"]], type[Annotated[object, "hello"]]
+    )
+    assert not subclasscheck(type[Annotated[object, "hello"]], type[Annotated[int, "hello"]])
+    assert not subclasscheck(type[Annotated[int, "hello"]], type[Annotated[int, "world"]])
+    assert not subclasscheck(type[Annotated[int, "hello"]], type[int])
+    assert not subclasscheck(type[int], type[Annotated[int, "hello"]])
+
+
+def test_subclasscheck_anntype_type():
+    assert subclasscheck(type[Annotated[int, "hello"]], type[Annotated[int, str]])
+    assert subclasscheck(type[Annotated[int, str]], type[Annotated[object, str]])
+    assert not subclasscheck(type[Annotated[int, "hello"]], type[Annotated[int, int]])
+
+
+@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
+    )
+    assert (
+        typeorder(type[Annotated[object, "hello"]], type[Annotated[int, "world"]])
+        is Order.MORE
+    )
+    assert typeorder(type[Annotated[int, "hello"]], type[int]) is Order.SAME
+    assert typeorder(type[int], type[Annotated[int, "hello"]]) is Order.SAME
+
+    zap = Anno("zap", 2)
+    zop = Anno("zap", 5)
+    assert typeorder(type[Annotated[int, zap]], type[Annotated[int, zop]]) is Order.MORE
+    assert typeorder(type[Annotated[int, zop]], type[Annotated[int, zap]]) is Order.LESS
+
+
 def test_subclasscheck_type_union():
     assert subclasscheck(type[Union[int, str]], type[Union])
     assert subclasscheck(type[Union], object)

{ovld-0.5.7 → ovld-0.5.9}/tests/test_ovld.py

@@ -3,6 +3,7 @@ import re
 import sys
 import typing
 from dataclasses import dataclass
+from typing import Annotated, Any
 
 import pytest
 
@@ -21,7 +22,7 @@ from ovld import (
 )
 from ovld.dependent import Dependent, Equals, Regexp, StartsWith
 from ovld.types import UnionTypes
-from ovld.utils import MISSING, UsageError
+from ovld.utils import MISSING, ResolutionError, UsageError
 
 from .test_typemap import Animal, Bird, Mammal
 
@@ -1277,6 +1278,81 @@ def test_generic_type_argument():
     assert f(dict[str, int]) == "dict"
 
 
+def test_annotated_type_argument():
+    @ovld
+    def f(t: type[Annotated[str, "hello"]]):
+        return "hello"
+
+    @ovld
+    def f(t: type[Annotated[str, "world"]]):
+        return "world"
+
+    @ovld
+    def f(t: object):
+        return False
+
+    assert f(Annotated[str, "hello"]) == "hello"
+    assert f(Annotated[str, "world"]) == "world"
+    assert f(Annotated[str, "hello", "X"]) == "hello"
+    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
+    annotation_priority: int = 0
+
+
+def test_annotated_multiple_ann():
+    hello = Anno("hello", 1)
+    world = Anno("hello", 2)
+    foo = Anno("foo", 1)
+    bar = Anno("bar", 1)
+
+    @ovld
+    def f(t: type[Annotated[str, hello]]):
+        return "hello"
+
+    @ovld
+    def f(t: type[Annotated[str, world]]):
+        return "world"
+
+    @ovld
+    def f(t: type[Annotated[str, foo]]):
+        return "foo"
+
+    @ovld
+    def f(t: type[Annotated[object, bar]]):
+        return "bar"
+
+    @ovld
+    def f(t: object):
+        return False
+
+    assert f(Annotated[str, hello, world]) == "world"
+    assert f(Annotated[str, hello, bar]) == "hello"
+    with pytest.raises(ResolutionError):
+        assert f(Annotated[str, hello, foo]) == "world"
+    assert f("ah") is False
+
+
 def test_any():
     @ovld
     def f(x: int):

{ovld-0.5.7 → ovld-0.5.9}/uv.lock

@@ -171,7 +171,7 @@ name = "importlib-metadata"
 version = "8.7.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "zipp" },
+    { name = "zipp", marker = "python_full_version < '3.10'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/76/66/650a33bd90f786193e4de4b3ad86ea60b53c89b669a5c7be931fac31cdb0/importlib_metadata-8.7.0.tar.gz", hash = "sha256:d13b81ad223b890aa16c5471f2ac3056cf76c5f10f82d6f9292f0b415f389000", size = 56641, upload-time = "2025-04-27T15:29:01.736Z" }
 wheels = [
@@ -370,7 +370,7 @@ wheels = [
 
 [[package]]
 name = "ovld"
-version = "0.5.6"
+version = "0.5.8"
 source = { editable = "." }
 
 [package.dev-dependencies]

ovld-0.5.7/src/ovld/version.py

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