ovld 0.4.0__py3-none-any.whl → 0.4.2__py3-none-any.whl

ovld/__init__.py

@@ -70,4 +70,5 @@ __all__ = [
     "keyword_decorator",
     "call_next",
     "recurse",
+    "__version__",
 ]

ovld/core.py

@@ -20,12 +20,6 @@ from .typemap import MultiTypeMap, is_type_of_type
 from .types import normalize_type
 from .utils import UsageError, keyword_decorator
 
-try:
-    from types import UnionType
-except ImportError:  # pragma: no cover
-    UnionType = None
-
-
 _current_id = itertools.count()
 
 
@@ -91,6 +85,7 @@ class Signature:
     req_names: frozenset
     vararg: bool
     priority: float
+    tiebreak: int = 0
     is_method: bool = False
     arginfo: list[Arginfo] = field(
         default_factory=list, hash=False, compare=False
@@ -399,8 +394,8 @@ class _Ovld:
             )
         else:
             hlp = ""
-            for p, prio, spc in possibilities:
-                hlp += f"* {p.__name__}  (priority: {prio}, specificity: {list(spc)})\n"
+            for c in possibilities:
+                hlp += f"* {c.handler.__name__}  (priority: {c.priority}, specificity: {list(c.specificity)})\n"
             return TypeError(
                 f"Ambiguous resolution in {self} for"
                 f" argument types [{typenames}]\n"
@@ -509,7 +504,15 @@ class _Ovld:
             raise TypeError(
                 f"There is already a method for {sigstring(sig.types)}"
             )
-        self._defns[sig] = fn
+
+        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._update()
         return self

ovld/mro.py

@@ -25,6 +25,16 @@ class TypeRelationship:
     matches: bool = None
 
 
+def _issubclass(t1, t2):
+    try:
+        return issubclass(t1, t2)
+    except TypeError:
+        try:
+            return isinstance(t1, t2)
+        except TypeError:  # pragma: no cover
+            return False
+
+
 def typeorder(t1, t2):
     """Order relation between two types.
 
@@ -56,6 +66,8 @@ def typeorder(t1, t2):
     o2 = getattr(t2, "__origin__", None)
 
     if o2 is typing.Union:
+        if t1 is typing.Union:
+            return Order.MORE
         compare = [
             x for t in t2.__args__ if (x := typeorder(t1, t)) is not Order.NONE
         ]
@@ -105,8 +117,8 @@ def typeorder(t1, t2):
             # Not sure when t1 != t2 and that happens
             return Order.SAME
 
-    sx = issubclass(t1, t2)
-    sy = issubclass(t2, t1)
+    sx = _issubclass(t1, t2)
+    sy = _issubclass(t2, t1)
     if sx and sy:  # pragma: no cover
         # Not sure when t1 != t2 and that happens
         return Order.SAME
@@ -136,14 +148,23 @@ def subclasscheck(t1, t2):
     o2 = getattr(t2, "__origin__", None)
 
     if o2 is typing.Union:
-        return any(subclasscheck(t1, t) for t in t2.__args__)
+        return t1 is typing.Union or any(
+            subclasscheck(t1, t) for t in t2.__args__
+        )
     elif o1 is typing.Union:
-        return all(subclasscheck(t, t2) for t in t1.__args__)
+        return t2 is typing.Union or all(
+            subclasscheck(t, t2) for t in t1.__args__
+        )
+
+    if not isinstance(o1, type):
+        o1 = None
+    if not isinstance(o2, type):
+        o2 = None
 
     if o1 or o2:
         o1 = o1 or t1
         o2 = o2 or t2
-        if issubclass(o1, o2):
+        if _issubclass(o1, o2):
             if o2 is t2:  # pragma: no cover
                 return True
             else:
@@ -157,7 +178,7 @@ def subclasscheck(t1, t2):
         else:
             return False
     else:
-        return issubclass(t1, t2)
+        return _issubclass(t1, t2)
 
 
 def sort_types(cls, avail):

ovld/recode.py

@@ -373,6 +373,7 @@ class NameConverter(ast.NodeTransformer):
         self.call_next_sym = call_next_sym
         self.ovld_mangled = ovld_mangled
         self.code_mangled = code_mangled
+        self.count = count()
 
     def visit_Name(self, node):
         if node.id == self.recurse_sym:
@@ -396,15 +397,16 @@ class NameConverter(ast.NodeTransformer):
             return self.generic_visit(node)
 
         cn = node.func.id == self.call_next_sym
+        tmp = f"__TMP{next(self.count)}_"
 
         def _make_lookup_call(key, arg):
             value = ast.NamedExpr(
-                target=ast.Name(id=f"__TMP{key}", ctx=ast.Store()),
+                target=ast.Name(id=f"{tmp}{key}", ctx=ast.Store()),
                 value=self.visit(arg),
             )
             if self.analysis.lookup_for(key) == "self.map.transform":
                 func = ast.Attribute(
-                    value=ast.Name(id="__TMPM", ctx=ast.Load()),
+                    value=ast.Name(id=f"{tmp}M", ctx=ast.Load()),
                     attr="transform",
                     ctx=ast.Load(),
                 )
@@ -437,7 +439,7 @@ class NameConverter(ast.NodeTransformer):
             type_parts.insert(0, ast.Name(id=self.code_mangled, ctx=ast.Load()))
         method = ast.Subscript(
             value=ast.NamedExpr(
-                target=ast.Name(id="__TMPM", ctx=ast.Store()),
+                target=ast.Name(id=f"{tmp}M", ctx=ast.Store()),
                 value=ast.Attribute(
                     value=ast.Name(id=self.ovld_mangled, ctx=ast.Load()),
                     attr="map",
@@ -464,13 +466,13 @@ class NameConverter(ast.NodeTransformer):
         new_node = ast.Call(
             func=method,
             args=[
-                ast.Name(id=f"__TMP{i}", ctx=ast.Load())
+                ast.Name(id=f"{tmp}{i}", ctx=ast.Load())
                 for i, arg in enumerate(node.args)
             ],
             keywords=[
                 ast.keyword(
                     arg=kw.arg,
-                    value=ast.Name(id=f"__TMP{kw.arg}", ctx=ast.Load()),
+                    value=ast.Name(id=f"{tmp}{kw.arg}", ctx=ast.Load()),
                 )
                 for kw in node.keywords
             ],

ovld/typemap.py

@@ -1,6 +1,7 @@
 import inspect
 import math
 import typing
+from dataclasses import dataclass
 from itertools import count
 from types import CodeType
 
@@ -69,6 +70,27 @@ class TypeMap(dict):
             raise KeyError(obj_t)
 
 
+@dataclass
+class Candidate:
+    handler: object
+    priority: float
+    specificity: tuple
+    tiebreak: int
+
+    def sort_key(self):
+        return self.priority, sum(self.specificity), self.tiebreak
+
+    def dominates(self, other):
+        if self.priority > other.priority:
+            return True
+        elif self.specificity != other.specificity:
+            return all(
+                s1 >= s2 for s1, s2 in zip(self.specificity, other.specificity)
+            )
+        else:
+            return self.tiebreak > other.tiebreak
+
+
 class MultiTypeMap(dict):
     """Represents a mapping from tuples of types to handlers.
 
@@ -91,6 +113,7 @@ class MultiTypeMap(dict):
     def __init__(self, name="_ovld", key_error=KeyError):
         self.maps = {}
         self.priorities = {}
+        self.tiebreaks = {}
         self.dependent = {}
         self.type_tuples = {}
         self.empty = MISSING
@@ -155,7 +178,12 @@ class MultiTypeMap(dict):
                 specificities.setdefault(c, []).append(results[c])
 
         candidates = [
-            (c, self.priorities.get(c, 0), tuple(specificities[c]))
+            Candidate(
+                handler=c,
+                priority=self.priorities.get(c, 0),
+                specificity=tuple(specificities[c]),
+                tiebreak=self.tiebreaks.get(c, 0),
+            )
             for c in candidates
         ]
 
@@ -164,33 +192,30 @@ class MultiTypeMap(dict):
         # other possibilities on all arguments, so the sum of all specificities
         # has to be greater.
         # Note: priority is always more important than specificity
-        candidates.sort(key=lambda cspc: (cspc[1], sum(cspc[2])), reverse=True)
+
+        candidates.sort(key=Candidate.sort_key, reverse=True)
 
         self.all[obj_t_tup] = {
-            getattr(c[0], "__code__", None) for c in candidates
+            getattr(c.handler, "__code__", None) for c in candidates
         }
 
         processed = set()
 
         def _pull(candidates):
-            candidates = [
-                (c, a, b) for (c, a, b) in candidates if c not in processed
-            ]
+            candidates = [c for c in candidates if c.handler not in processed]
             if not candidates:
                 return
             rval = [candidates[0]]
-            c1, p1, spc1 = candidates[0]
-            for c2, p2, spc2 in candidates[1:]:
-                if p1 > p2 or (
-                    spc1 != spc2 and all(s1 >= s2 for s1, s2 in zip(spc1, spc2))
-                ):
+            c1 = candidates[0]
+            for c2 in candidates[1:]:
+                if c1.dominates(c2):
                     # Candidate 1 dominates candidate 2
                     continue
                 else:
-                    processed.add(c2)
+                    processed.add(c2.handler)
                     # Candidate 1 does not dominate candidate 2, so we add it
                     # to the list.
-                    rval.append((c2, p2, spc2))
+                    rval.append(c2)
             yield rval
             if len(rval) >= 1:
                 yield from _pull(candidates[1:])
@@ -212,6 +237,7 @@ class MultiTypeMap(dict):
             self.empty = entry
 
         self.priorities[handler] = sig.priority
+        self.tiebreaks[handler] = sig.tiebreak
         self.type_tuples[handler] = obj_t_tup
         self.dependent[handler] = any(
             isinstance(t[1] if isinstance(t, tuple) else t, DependentType)
@@ -257,15 +283,16 @@ class MultiTypeMap(dict):
         finished = False
         rank = 1
         for grp in self.mro(tuple(argt)):
-            grp.sort(key=lambda x: x[0].__name__)
+            grp.sort(key=lambda x: x.handler.__name__)
             match = [
                 dependent_match(
-                    self.type_tuples[handler], [*args, *kwargs.items()]
+                    self.type_tuples[c.handler], [*args, *kwargs.items()]
                 )
-                for handler, _, _ in grp
+                for c in grp
             ]
             ambiguous = len([m for m in match if m]) > 1
-            for m, (handler, prio, spec) in zip(match, grp):
+            for m, c in zip(match, grp):
+                handler = c.handler
                 color = "\033[0m"
                 if finished:
                     bullet = "--"
@@ -282,8 +309,8 @@ class MultiTypeMap(dict):
                         message = f"{handler.__name__} will be called first."
                         color = "\033[1;32m"
                     rank += 1
-                spec = ".".join(map(str, spec))
-                lvl = f"[{prio}:{spec}]"
+                spec = ".".join(map(str, c.specificity))
+                lvl = f"[{c.priority}:{spec}]"
                 width = 2 * len(args) + 6
                 print(f"{color}{bullet} {lvl:{width}} {handler.__name__}")
                 co = handler.__code__
@@ -320,8 +347,8 @@ class MultiTypeMap(dict):
 
         funcs = []
         for group in reversed(results):
-            handlers = [fn for (fn, _, _) in group]
-            dependent = any(self.dependent[fn] for (fn, _, _) in group)
+            handlers = [c.handler for c in group]
+            dependent = any(self.dependent[c.handler] for c in group)
             if dependent:
                 nxt = self.wrap_dependent(
                     obj_t_tup, handlers, group, funcs[-1] if funcs else None

ovld/version.py

@@ -1 +1 @@
-version = "0.4.0"
+version = "0.4.2"

{ovld-0.4.0.dist-info → ovld-0.4.2.dist-info}/METADATA

@@ -1,7 +1,10 @@
 Metadata-Version: 2.3
 Name: ovld
-Version: 0.4.0
+Version: 0.4.2
 Summary: Overloading Python functions
+Project-URL: Homepage, https://ovld.readthedocs.io/en/latest/
+Project-URL: Documentation, https://ovld.readthedocs.io/en/latest/
+Project-URL: Repository, https://github.com/breuleux/ovld
 Author-email: Olivier Breuleux <breuleux@gmail.com>
 License-Expression: MIT
 License-File: LICENSE

ovld-0.4.2.dist-info/RECORD

@@ -0,0 +1,13 @@
+ovld/__init__.py,sha256=Vp9wbIy_opFmJx-vCcToQcIP3cWFIvgbfYHITyiwPLs,1305
+ovld/core.py,sha256=glexOiRU0ajoxFAQN6d69ToL6_cPvyv05Z7LEHqrJj8,25701
+ovld/dependent.py,sha256=QITsWu2uCwqkHE0tunETy8Jqwc272uoG5YM0I5yy0m4,7303
+ovld/mro.py,sha256=rS0pCLLWwLUI0NdthpoJSrdvWR4-XgRfx1pLAvJde14,5586
+ovld/recode.py,sha256=zxhyotuc73qzuN4NEN_rKxaqoA0SOH7KFtE2l_CRBFs,17963
+ovld/typemap.py,sha256=gw8XvB-N_15Dr0-am0v17x1seNjYK5AxvUT9L36mWic,13630
+ovld/types.py,sha256=Zeb7xhHbL4T7qIRHI-I_cjG61UIWrfZv_EwjwqhB-rY,6381
+ovld/utils.py,sha256=V6Y8oZ6ojq8JaODL1rMZbU5L9QG0YSqHNYmpIFiwy3M,1294
+ovld/version.py,sha256=OHlqRD04Kvw_CFYmiIVx7UuOJRTQKtAx1Bl4rkUYHJE,18
+ovld-0.4.2.dist-info/METADATA,sha256=fV3vxTKRAjCUkRVNmzTW14VajGSl7P0b9NnG06cjUJk,7713
+ovld-0.4.2.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+ovld-0.4.2.dist-info/licenses/LICENSE,sha256=cSwNTIzd1cbI89xt3PeZZYJP2y3j8Zus4bXgo4svpX8,1066
+ovld-0.4.2.dist-info/RECORD,,

ovld-0.4.0.dist-info/RECORD

@@ -1,13 +0,0 @@
-ovld/__init__.py,sha256=nF8ymgr8dSL2WvDpOXVxqDuEGUywbkiCGr4ICumMD8U,1286
-ovld/core.py,sha256=siahCDuw78n02-2g7TGI1GerrGvPxT0zPouN6Z30Z-g,25497
-ovld/dependent.py,sha256=QITsWu2uCwqkHE0tunETy8Jqwc272uoG5YM0I5yy0m4,7303
-ovld/mro.py,sha256=dNuVW5DIOT8TJtY4vEpxT4q3R8fQxJ8UyDQSD9oFYYo,5116
-ovld/recode.py,sha256=Vc97Nv1j2GWuitLOzIuIhpscZ4gaOJQP3hLNp8SGTQ8,17890
-ovld/typemap.py,sha256=U_BmXtts1oYVa6gI3cgGHMX5kFcCJY_mt_cjWvDo3jQ,12979
-ovld/types.py,sha256=Zeb7xhHbL4T7qIRHI-I_cjG61UIWrfZv_EwjwqhB-rY,6381
-ovld/utils.py,sha256=V6Y8oZ6ojq8JaODL1rMZbU5L9QG0YSqHNYmpIFiwy3M,1294
-ovld/version.py,sha256=yhiWOz0HoJGRRI9-JQ2eh_0AbByy-6psK08-kpTSHJw,18
-ovld-0.4.0.dist-info/METADATA,sha256=4NkzmXbqa8ZNCwESYT4U8yILZyaIlw1rcghfCyaT50U,7526
-ovld-0.4.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-ovld-0.4.0.dist-info/licenses/LICENSE,sha256=cSwNTIzd1cbI89xt3PeZZYJP2y3j8Zus4bXgo4svpX8,1066
-ovld-0.4.0.dist-info/RECORD,,