ovld 0.5.8__tar.gz → 0.5.10__tar.gz

{ovld-0.5.8 → ovld-0.5.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ovld
-Version: 0.5.8
+Version: 0.5.10
 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.8 → ovld-0.5.10}/pyproject.toml

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

{ovld-0.5.8 → ovld-0.5.10}/src/ovld/core.py

@@ -25,6 +25,21 @@ from .utils import (
     subtler_type,
 )
 
+_orig_getdoc = inspect.getdoc
+
+
+def _getdoc(fn):
+    if hasattr(fn, "__calculate_doc__"):
+        if inspect.ismethod(fn):
+            fn = fn.__func__
+        fn.__doc__ = fn.__calculate_doc__()
+        del fn.__calculate_doc__
+    return _orig_getdoc(fn)
+
+
+inspect.getdoc = _getdoc
+
+
 _current_id = itertools.count()
 
 
@@ -72,8 +87,6 @@ class Ovld:
             dispatch.
         linkback: Whether to keep a pointer in the parent mixins to this
             ovld so that updates can be propagated. (default: False)
-        allow_replacement: Allow replacing a method by another with the
-            same signature. (default: True)
     """
 
     def __init__(
@@ -82,50 +95,43 @@ class Ovld:
         mixins=[],
         name=None,
         linkback=False,
-        allow_replacement=True,
     ):
         """Initialize an Ovld."""
         self.id = next(_current_id)
         self.specialization_self = MISSING
         self._compiled = False
+        self._signatures = None
+        self._argument_analysis = None
         self.linkback = linkback
         self.children = []
-        self.allow_replacement = allow_replacement
         self.name = name
         self.shortname = name or f"__OVLD{self.id}"
         self.__name__ = name
-        self._defns = {}
+        self._regs = {}
         self._locked = False
         self.mixins = []
-        self.argument_analysis = ArgumentAnalyzer()
         self.dispatch = bootstrap_dispatch(self, name=self.shortname)
         self.add_mixins(*mixins)
 
-    @property
-    def defns(self):
-        defns = {}
+    def regs(self):
         for mixin in self.mixins:
-            defns.update(mixin.defns)
-        defns.update(self._defns)
-        return defns
+            yield from mixin.regs()
+        yield from self._regs.items()
 
-    def analyze_arguments(self):
-        self.argument_analysis = ArgumentAnalyzer()
-        for key, fn in list(self.defns.items()):
-            self.argument_analysis.add(fn)
-        self.argument_analysis.compile()
-        return self.argument_analysis
+    def empty(self):
+        return not self._regs and all(m.empty() for m in self.mixins)
 
     def mkdoc(self):
+        fns = [f for f, _ in self.regs()]
         try:
-            docs = [fn.__doc__ for fn in self.defns.values() if fn.__doc__]
+            docs = [fn.__doc__ for fn in fns if fn.__doc__]
             if len(docs) == 1:
                 maindoc = docs[0]
             else:
-                maindoc = f"Ovld with {len(self.defns)} methods."
+                maindoc = f"Ovld with {len(fns)} methods."
 
             doc = f"{maindoc}\n\n"
-            for fn in self.defns.values():
+            for fn in fns:
                 fndef = inspect.signature(fn)
                 fdoc = fn.__doc__
                 if not fdoc or fdoc == maindoc:
@@ -192,17 +198,41 @@ class Ovld:
     def __set_name__(self, inst, name):
         self.rename(name)
 
-    def _set_attrs_from(self, fn):
-        """Inherit relevant attributes from the function."""
-        if self.name is None:
-            self.__qualname__ = fn.__qualname__
-            self.__module__ = fn.__module__
-            self.rename(f"{fn.__module__}.{fn.__qualname__}", fn.__name__)
-
     def ensure_compiled(self):
         if not self._compiled:
             self.compile()
 
+    @property
+    def signatures(self):
+        if self._signatures is None:
+            regs = {}
+            for fn, priority in self.regs():
+                ss = self.specialization_self
+                cgf = getattr(ss, "_ovld_codegen_fields", ())
+                lcl = {f: getattr(ss, f) for f in cgf}
+                sig = replace(Signature.extract(fn, lcl), priority=priority)
+
+                def _set(sig, fn):
+                    if sig in regs:
+                        # Push down the existing handler with a lower tiebreak
+                        msig = replace(sig, tiebreak=sig.tiebreak - 1)
+                        _set(msig, regs[sig])
+                    regs[sig] = fn
+
+                _set(sig, fn)
+            self._signatures = regs
+        return self._signatures
+
+    @property
+    def argument_analysis(self):
+        if self._argument_analysis is None:
+            aa = ArgumentAnalyzer()
+            for sig in self.signatures:
+                aa.add(sig)
+            aa.compile()
+            self._argument_analysis = aa
+        return self._argument_analysis
+
     def compile(self):
         """Finalize this overload.
 
@@ -223,7 +253,9 @@ class Ovld:
         name = self.__name__
         self.map = MultiTypeMap(name=name, key_error=self._key_error, ovld=self)
 
-        self.analyze_arguments()
+        for sig, fn in list(self.signatures.items()):
+            self.register_signature(sig, fn)
+
         dispatch = generate_dispatch(self, self.argument_analysis)
         self.dispatch.__code__ = rename_code(dispatch.__code__, self.shortname)
         self.dispatch.__kwdefaults__ = dispatch.__kwdefaults__
@@ -231,10 +263,7 @@ class Ovld:
         self.dispatch.__defaults__ = dispatch.__defaults__
         self.dispatch.__globals__.update(dispatch.__globals__)
         self.dispatch.map = self.map
-        self.dispatch.__doc__ = self.mkdoc()
-
-        for key, fn in list(self.defns.items()):
-            self.register_signature(key, fn)
+        self.dispatch.__generate_doc__ = self.mkdoc
 
         self._compiled = True
 
@@ -275,42 +304,35 @@ class Ovld:
     def _register(self, fn, priority):
         """Register a function."""
 
-        self._attempt_modify()
-
-        self._set_attrs_from(fn)
-
-        sig = replace(Signature.extract(fn), priority=priority)
-        if not self.allow_replacement and sig in self._defns:
-            raise TypeError(f"There is already a method for {sigstring(sig.types)}")
+        if not isinstance(priority, tuple):
+            priority = (priority,)
 
-        def _set(sig, fn):
-            if sig in self._defns:
-                # Push down the existing handler with a lower tiebreak
-                msig = replace(sig, tiebreak=sig.tiebreak - 1)
-                _set(msig, self._defns[sig])
-            self._defns[sig] = fn
-
-        _set(sig, fn)
+        self._attempt_modify()
+        if self.name is None:
+            self.__qualname__ = fn.__qualname__
+            self.__module__ = fn.__module__
+            self.rename(f"{fn.__module__}.{fn.__qualname__}", fn.__name__)
+        self._regs[fn] = priority
 
-        self._update()
+        self.invalidate()
         return self
 
     def unregister(self, fn):
         """Unregister a function."""
         self._attempt_modify()
-        self._defns = {sig: f for sig, f in self._defns.items() if f is not fn}
-        self._update()
-
-    def _update(self):
-        self.reset()
+        del self._regs[fn]
+        self.invalidate()
+
+    def invalidate(self):
+        self._signatures = None
+        self._argument_analysis = None
+        if self._compiled:
+            self._compiled = False
+            self.dispatch.__code__ = self.dispatch.first_entry.__code__
         for child in self.children:
-            child._update()
+            child.invalidate()
         if hasattr(self, "dispatch"):
-            self.dispatch.__doc__ = self.mkdoc()
-
-    def reset(self):
-        self._compiled = False
-        self.dispatch.__code__ = self.dispatch.first_entry.__code__
+            self.dispatch.__calculate_doc__ = self.mkdoc
 
     def copy(self, mixins=[], linkback=False):
         """Create a copy of this Ovld.

{ovld-0.5.8 → ovld-0.5.10}/src/ovld/medley.py

@@ -123,9 +123,9 @@ class BuildOvld(Combiner):
         for f, arg in self.pending:
             f(arg)
         self.pending.clear()
-        if not self.ovld.defns:
+        if self.ovld.empty():
             return ABSENT
-        self.ovld.reset()
+        self.ovld.invalidate()
         return self.ovld.dispatch
 
     def copy(self):
@@ -337,15 +337,20 @@ _meld_classes_cache = {}
 
 
 def meld_classes(classes):
+    def key(cls):
+        return getattr(cls, "_ovld_specialization_parent", None) or cls
+
     medleys = {}
     for cls in classes:
-        medleys.update({x: True for x in getattr(cls, "_ovld_medleys", [cls])})
+        medleys.update({key(x): x for x in getattr(cls, "_ovld_medleys", [cls])})
     for cls in classes:
+        cls = key(cls)
         if not hasattr(cls, "_ovld_medleys"):
             for base in cls.mro():
                 if base is not cls and base in medleys:
                     del medleys[base]
-    medleys = tuple(medleys)
+
+    medleys = tuple(medleys.values())
     if len(medleys) == 1:
         return medleys[0]
 
@@ -372,7 +377,7 @@ def meld_classes(classes):
 
     result = make_dataclass(
         cls_name="+".join(sorted(c.__name__ for c in medleys)),
-        bases=tuple(medleys),
+        bases=medleys,
         fields=dc_fields,
         kw_only=True,
         namespace=merged,

{ovld-0.5.8 → ovld-0.5.10}/src/ovld/mro.py

@@ -118,8 +118,8 @@ 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
+    if not isinstance(t1, type) or not isinstance(t2, type):
+        return Order.NONE
 
     sx = issubclass(t1, t2)
     sy = issubclass(t2, t1)
@@ -134,6 +134,15 @@ 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 or t2 is Any:
@@ -165,7 +174,7 @@ def subclasscheck(t1, 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(ann in a2 for ann in a1)
+        return subclasscheck(t1, t2) and any(_find_ann(main, a1) for main in a2)
 
     if o1 is Annotated:
         return t2 is Annotated

{ovld-0.5.8 → ovld-0.5.10}/src/ovld/signatures.py

@@ -30,7 +30,7 @@ class LazySignature(inspect.Signature):
 
     @property
     def parameters(self):
-        anal = self.ovld.analyze_arguments()
+        anal = self.ovld.argument_analysis
         parameters = []
         if anal.is_method:
             parameters.append(
@@ -117,7 +117,7 @@ class Signature:
     arginfo: list[Arginfo] = field(default_factory=list, hash=False, compare=False)
 
     @classmethod
-    def extract(cls, fn):
+    def extract(cls, fn, lcl={}):
         typelist = []
         sig = inspect.signature(fn)
         max_pos = 0
@@ -135,7 +135,7 @@ class Signature:
                 is_method = True
                 continue
             pos = nm = None
-            ann = normalize_type(param.annotation, fn)
+            ann = normalize_type(param.annotation, fn, lcl)
             if param.kind is inspect._POSITIONAL_ONLY:
                 pos = i - is_method
                 typelist.append(ann)
@@ -188,9 +188,8 @@ class ArgumentAnalyzer:
         self.is_method = None
         self.done = False
 
-    def add(self, fn):
+    def add(self, sig):
         self.done = False
-        sig = Signature.extract(fn)
         self.complex_transforms.update(arg.canonical for arg in sig.arginfo if arg.is_complex)
         for arg in sig.arginfo:
             if arg.position is not None:

{ovld-0.5.8 → ovld-0.5.10}/src/ovld/typemap.py

@@ -242,7 +242,8 @@ class MultiTypeMap(dict):
             self.maps[-1].register(object, entry)
 
     def display_methods(self):
-        for h, prio in sorted(self.priorities.items(), key=lambda kv: -kv[1]):
+        for h, prio in sorted(self.priorities.items(), key=lambda kv: kv[1], reverse=True):
+            prio = ":".join(map(str, prio))
             prio = f"[{prio}]"
             width = 6
             print(f"{prio:{width}} \033[1m{h.__name__}\033[0m")
@@ -306,7 +307,8 @@ class MultiTypeMap(dict):
                         color = "\033[1;32m"
                     rank += 1
                 spec = ".".join(map(str, c.specificity))
-                lvl = f"[{c.priority}:{spec}]"
+                prios = ":".join(map(str, c.priority))
+                lvl = f"[{prios}:{spec}]"
                 width = 2 * len(args) + 6
                 print(f"{color}{bullet} {lvl:{width}} {handler.__name__}")
                 co = handler.__code__

{ovld-0.5.8 → ovld-0.5.10}/src/ovld/types.py

@@ -25,7 +25,7 @@ def eval_annotation(t, ctx, locals, catch=False):
             else:  # pragma: no cover
                 glb = {}
             return eval(t, glb, locals)
-        else:
+        else:  # pragma: no cover
             return t
     except Exception:  # pragma: no cover
         if catch:
@@ -43,11 +43,11 @@ class TypeNormalizer:
         else:
             self.generic_handlers.register(generic, handler)
 
-    def __call__(self, t, fn):
+    def __call__(self, t, fn, lcl={}):
         from .dependent import DependentType
 
         if isinstance(t, str):
-            t = eval_annotation(t, fn, {})
+            t = eval_annotation(t, fn, lcl)
 
         if t is type:
             t = type[object]

ovld-0.5.10/src/ovld/version.py

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

{ovld-0.5.8 → ovld-0.5.10}/tests/test_abc.py

@@ -30,16 +30,20 @@ def test_literal():
     assert f(4) == "nah"
 
 
+def f_i(i):
+    def f(x: Literal[i]):
+        return x * x
+
+    return f
+
+
 def test_many_literals():
     f = Ovld()
 
     n = 10
 
     for i in range(n):
-
-        @ovld
-        def f(x: Literal[i]):
-            return x * x
+        f.register(f_i(i))
 
     for i in range(n):
         assert f(i) == i * i

{ovld-0.5.8 → ovld-0.5.10}/tests/test_dependent.py

@@ -337,11 +337,25 @@ def test_keyed_plus_other():
     # Tests a failure mode of generating dispatch code like HANDLER = HANDLERS[x]
     # if you also have to check a condition on y.
 
-    for i in range(10):
+    @ovld
+    def f(x: Literal[0], y: Bounded[0, 100]):
+        return "yes"
 
-        @ovld
-        def f(x: Literal[i], y: Bounded[0, 100]):
-            return "yes"
+    @ovld
+    def f(x: Literal[1], y: Bounded[0, 100]):
+        return "yes"
+
+    @ovld
+    def f(x: Literal[2], y: Bounded[0, 100]):
+        return "yes"
+
+    @ovld
+    def f(x: Literal[3], y: Bounded[0, 100]):
+        return "yes"
+
+    @ovld
+    def f(x: Literal[4], y: Bounded[0, 100]):
+        return "yes"
 
     @ovld
     def f(x: int, y: int):

{ovld-0.5.8 → ovld-0.5.10}/tests/test_medley.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import sys
 from dataclasses import field, replace
 from typing import Counter
@@ -7,6 +9,7 @@ import pytest
 from ovld import recurse
 from ovld.codegen import Code, Lambda, code_generator
 from ovld.core import ovld
+from ovld.dependent import Regexp
 from ovld.medley import (
     BuildOvld,
     ChainAll,
@@ -541,3 +544,31 @@ def test_default_factory_inheritance():
 
     lu = Lust()
     assert lu.xs == []
+
+
+class Monkey(Medley):
+    regex: CodegenParameter[str] = "monk[iey]+"
+
+    def hi(self, x: Regexp[regex]):
+        return "hello!"
+
+    def hi(self, x: str):
+        return "goodbye!"
+
+
+def test_configure_dependent():
+    m1 = Monkey()
+    m2 = Monkey(regex="go+rilla")
+
+    assert m1.hi("monki") == "hello!"
+    assert m1.hi("monkeeeee") == "hello!"
+    assert m1.hi("goorilla") == "goodbye!"
+
+    assert m2.hi("monki") == "goodbye!"
+    assert m2.hi("monkeeeee") == "goodbye!"
+    assert m2.hi("goorilla") == "hello!"
+
+
+def test_configure_dependent_pileon():
+    m = Monkey(regex="chimpanze+") + Monkey(regex="go+rilla")
+    assert m.hi("goorilla") == "hello!"

{ovld-0.5.8 → ovld-0.5.10}/tests/test_mro.py

@@ -9,6 +9,7 @@ from ovld.mro import Order, subclasscheck, typeorder
 from ovld.types import (
     All,
     Dataclass,
+    HasMethod,
     Intersection,
     Order,
     Union,
@@ -150,6 +151,12 @@ def test_subclasscheck_anntype():
     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"
 )
@@ -164,6 +171,11 @@ def test_typeorder_any():
     assert typeorder(Any, Any) is Order.SAME
 
 
+def test_typeorder_exotic():
+    assert typeorder(HasMethod["meth"], Annotated) is Order.NONE
+    assert typeorder(Annotated, HasMethod["meth"]) is Order.NONE
+
+
 @dataclass(frozen=True)
 class Anno:
     name: str

{ovld-0.5.8 → ovld-0.5.10}/tests/test_ovld/test_doc.txt

@@ -9,5 +9,4 @@ mushroom(x: str)
     Naming mushrooms.
 
 mushroom(x: str, y: object, *, beauty, bigness)
-    Whatever.
-
+    Whatever.

{ovld-0.5.8 → ovld-0.5.10}/tests/test_ovld/test_doc2.txt

@@ -6,5 +6,4 @@ mushroom(x: int)
 
 mushroom(x: str)
 
-mushroom(x: str, y: object, *, beauty, bigness)
-
+mushroom(x: str, y: object, *, beauty, bigness)

{ovld-0.5.8 → ovld-0.5.10}/tests/test_ovld/test_method_doc.txt

@@ -6,5 +6,4 @@ rise(self, x: int)
 
 rise(self, x: str)
 
-rise(self, x: str, y: object, *, beauty, bigness)
-
+rise(self, x: str, y: object, *, beauty, bigness)

{ovld-0.5.8 → ovld-0.5.10}/tests/test_ovld.py

@@ -809,6 +809,20 @@ def test_priority():
     assert f([1, "x"]) == ["TOP", [["TOP", 2], ["TOP", "BOTTOM"]]]
 
 
+def test_priority_tuple():
+    f = Ovld()
+
+    @f.register(priority=(1, 2))
+    def f(x: object):
+        return ["TOP", call_next(x)]
+
+    @f.register(priority=(1, 1))
+    def f(x: object):
+        return "BOTTOM"
+
+    assert f(123) == ["TOP", "BOTTOM"]
+
+
 def test_resolve_for_values():
     f = Ovld()
 
@@ -1146,18 +1160,6 @@ def test_replacement():
     assert f(5) == 2
 
 
-def test_disallow_replacement():
-    @ovld(allow_replacement=False)
-    def f(x: int):
-        pass
-
-    with pytest.raises(TypeError):
-
-        @f.register
-        def f2(x: int):
-            pass
-
-
 def test_unregister():
     @ovld
     def f(xs: list):
@@ -1819,12 +1821,12 @@ def test_doc(file_regression):
         return None
 
     doc = f"{mushroom.__name__}{inspect.signature(mushroom)}\n\n"
-    doc += mushroom.__doc__
+    doc += inspect.getdoc(mushroom)
 
     file_regression.check(doc)
 
-    assert mushroom.__doc__ == mushroom.__ovld__.__doc__
-    assert mushroom.__signature__ == mushroom.__ovld__.__signature__
+    assert inspect.getdoc(mushroom) == inspect.getdoc(mushroom.__ovld__)
+    assert inspect.signature(mushroom) == inspect.signature(mushroom.__ovld__)
 
 
 def test_doc2(file_regression):
@@ -1841,7 +1843,7 @@ def test_doc2(file_regression):
     def mushroom(x: str, y: object, *, beauty, bigness):
         return None
 
-    doc = mushroom.__doc__
+    doc = inspect.getdoc(mushroom)
     doc = f"{mushroom.__name__}{inspect.signature(mushroom)}\n\n" + doc
 
     file_regression.check(doc)
@@ -1863,7 +1865,7 @@ def test_method_doc(file_regression):
             return None
 
     mushroom = Mushroom()
-    doc = mushroom.rise.__doc__
+    doc = inspect.getdoc(mushroom.rise)
     doc = f"{mushroom.rise.__name__}{inspect.signature(mushroom.rise)}\n\n" + doc
 
     file_regression.check(doc)