ovld 0.5.9__py3-none-any.whl → 0.5.10__py3-none-any.whl

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/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/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)

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/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/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/version.py

@@ -1 +1 @@
-version = "0.5.9"
+version = "0.5.10"

{ovld-0.5.9.dist-info → ovld-0.5.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ovld
-Version: 0.5.9
+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.10.dist-info/RECORD

@@ -0,0 +1,18 @@
+ovld/__init__.py,sha256=JuCM8Sj65gobV0KYyLr95cSI23Pi6RYZ7X3_F3fdsSw,1821
+ovld/abc.py,sha256=4qpZyYwI8dWgY1Oiv5FhdKg2uzNcyWxIpGmGJVcjXrs,1177
+ovld/codegen.py,sha256=27tmamlanuTPDT-x31ISyqP0wGKW9BCFZJGVyq9qLg8,9728
+ovld/core.py,sha256=vVvaQppGZcccgRuxMkdQCr9jXrG9_xJn3ohyT0bIkEA,18251
+ovld/dependent.py,sha256=JIgsc_5ddPH51_2IrZ6JW6bWE5RyrrrOwR2e9UvDhZ4,8922
+ovld/medley.py,sha256=qiYUtMbYR-fzvmqfr7BDY2Ht3SbNOEJ9VaR7s-BNGRo,12962
+ovld/mro.py,sha256=RxHoOpf5nIOD4yU-Bb0Zt5tFyral9zljaPDVGebnnJo,6218
+ovld/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ovld/recode.py,sha256=vXg9XLExp_9LdAHO0JWR4wvwHhpOLu2Xcrg9ZYg1nms,16407
+ovld/signatures.py,sha256=EXE5Jik8m-3UtkS1lgr3rl5QS7NRcJfuI3VRaU6v1bg,8960
+ovld/typemap.py,sha256=jcYiIPt8wVng0u7qdceEMt7i0gmlo7BMFbvHLkf6zD8,14092
+ovld/types.py,sha256=sP4xqx5jZ-gYnQ4LlvT5v7N8I1npNdKKZf72rBelvEA,13402
+ovld/utils.py,sha256=8nvycMWpTmwGq7ojjDA7yi2NdkU78NBdUlvRk_vDECY,5086
+ovld/version.py,sha256=H2w8gxble-MJwdr4ywy0-MXcLJNCr6buKONQqjAMUuQ,19
+ovld-0.5.10.dist-info/METADATA,sha256=TQnXuZ-NjT_wv8OGFY6zz33x7_4QGOcN6f3bNhNmBZw,10459
+ovld-0.5.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ovld-0.5.10.dist-info/licenses/LICENSE,sha256=cSwNTIzd1cbI89xt3PeZZYJP2y3j8Zus4bXgo4svpX8,1066
+ovld-0.5.10.dist-info/RECORD,,

ovld-0.5.9.dist-info/RECORD

@@ -1,18 +0,0 @@
-ovld/__init__.py,sha256=JuCM8Sj65gobV0KYyLr95cSI23Pi6RYZ7X3_F3fdsSw,1821
-ovld/abc.py,sha256=4qpZyYwI8dWgY1Oiv5FhdKg2uzNcyWxIpGmGJVcjXrs,1177
-ovld/codegen.py,sha256=27tmamlanuTPDT-x31ISyqP0wGKW9BCFZJGVyq9qLg8,9728
-ovld/core.py,sha256=WqZ1lvcAGSri02XZeY73Bj5AKB9RYBCAvHLbyns8u68,17792
-ovld/dependent.py,sha256=JIgsc_5ddPH51_2IrZ6JW6bWE5RyrrrOwR2e9UvDhZ4,8922
-ovld/medley.py,sha256=Pq6j4qPl8osyQ4Xp-ktnt2uJXytC9Jo70toS5LYHRf8,12840
-ovld/mro.py,sha256=-M-BFtmSSEZ39eMPpZ4c2xTAwE43zuJu_jtlxAEfuPo,6238
-ovld/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ovld/recode.py,sha256=vXg9XLExp_9LdAHO0JWR4wvwHhpOLu2Xcrg9ZYg1nms,16407
-ovld/signatures.py,sha256=Q8JucSOun0ESGx14aWtHtBzLEiM6FxY5HP3imyqXoDo,8984
-ovld/typemap.py,sha256=wkLuCc6xa2VZJOMaAhuYYgnNrywhovkQwbkBnoRfCsY,13985
-ovld/types.py,sha256=CRL6Vuzg5moXgAAhIj2698GvZoyF4HWbUDYz2hKt6us,13373
-ovld/utils.py,sha256=8nvycMWpTmwGq7ojjDA7yi2NdkU78NBdUlvRk_vDECY,5086
-ovld/version.py,sha256=fa8mYJ1rRpnvSWOBQjwJEtqO9AqOw8j-QGkxIJqUaM0,18
-ovld-0.5.9.dist-info/METADATA,sha256=7TIVCS1fVm0Oq7GcG5KR9JRNWQa6JkM-c6euVUu3e6g,10458
-ovld-0.5.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-ovld-0.5.9.dist-info/licenses/LICENSE,sha256=cSwNTIzd1cbI89xt3PeZZYJP2y3j8Zus4bXgo4svpX8,1066
-ovld-0.5.9.dist-info/RECORD,,