ovld 0.4.5__py3-none-any.whl → 0.5.0__py3-none-any.whl

ovld/typemap.py

@@ -6,7 +6,7 @@ from types import CodeType
 
 from .mro import sort_types
 from .recode import generate_dependent_dispatch
-from .utils import MISSING, subtler_type
+from .utils import MISSING, CodegenInProgress, subtler_type
 
 
 class TypeMap(dict):
@@ -58,6 +58,7 @@ class TypeMap(dict):
 @dataclass
 class Candidate:
     handler: object
+    base_handler: object
     priority: float
     specificity: tuple
     tiebreak: int
@@ -69,9 +70,7 @@ class Candidate:
         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)
-            )
+            return all(s1 >= s2 for s1, s2 in zip(self.specificity, other.specificity))
         else:
             return self.tiebreak > other.tiebreak
 
@@ -95,7 +94,7 @@ class MultiTypeMap(dict):
     specific than [object, int] (which means there is an ambiguity).
     """
 
-    def __init__(self, name="_ovld", key_error=KeyError):
+    def __init__(self, name="_ovld", key_error=KeyError, ovld=None):
         self.maps = {}
         self.priorities = {}
         self.tiebreaks = {}
@@ -107,8 +106,10 @@ class MultiTypeMap(dict):
         self.dispatch_id = count()
         self.all = {}
         self.errors = {}
+        self.ovld = ovld
+        self.in_progress = set()
 
-    def mro(self, obj_t_tup):
+    def mro(self, obj_t_tup, specialize=True):
         specificities = {}
         candidates = None
         nargs = len([t for t in obj_t_tup if not isinstance(t, tuple)])
@@ -126,9 +127,7 @@ class MultiTypeMap(dict):
             results = {
                 handler: spc
                 for (handler, sig), spc in results.items()
-                if sig.req_pos
-                <= nargs
-                <= (math.inf if sig.vararg else sig.max_pos)
+                if sig.req_pos <= nargs <= (math.inf if sig.vararg else sig.max_pos)
                 and not (sig.req_names - names)
             }
 
@@ -152,14 +151,26 @@ class MultiTypeMap(dict):
             for c in candidates:
                 specificities.setdefault(c, []).append(results[c])
 
+        def get_handler(func):
+            if specialize and (specializer := getattr(func, "specializer", False)):
+                key = (func, obj_t_tup)
+                if key in self.in_progress:
+                    raise CodegenInProgress()
+                self.in_progress.add(key)
+                return specializer(self, func, obj_t_tup)
+            else:
+                return func
+
         candidates = [
             Candidate(
-                handler=c,
+                handler=h,
+                base_handler=c,
                 priority=self.priorities.get(c, 0),
                 specificity=tuple(specificities[c]),
                 tiebreak=self.tiebreaks.get(c, 0),
             )
             for c in candidates
+            if (h := get_handler(c))
         ]
 
         # The sort ensures that if candidate A dominates candidate B, A will
@@ -170,9 +181,7 @@ class MultiTypeMap(dict):
 
         candidates.sort(key=Candidate.sort_key, reverse=True)
 
-        self.all[obj_t_tup] = {
-            getattr(c.handler, "__code__", None) for c in candidates
-        }
+        self.all[obj_t_tup] = {getattr(c.handler, "__code__", None) for c in candidates}
 
         processed = set()
 
@@ -239,7 +248,7 @@ class MultiTypeMap(dict):
             width = 6
             print(f"{prio:{width}} \033[1m{h.__name__}\033[0m")
             co = h.__code__
-            print(f"{'':{width-2}} @ {co.co_filename}:{co.co_firstlineno}")
+            print(f"{'':{width - 2}} @ {co.co_filename}:{co.co_firstlineno}")
 
     def display_resolution(self, *args, **kwargs):
         from .dependent import is_dependent
@@ -263,9 +272,7 @@ class MultiTypeMap(dict):
         for grp in self.mro(tuple(argt)):
             grp.sort(key=lambda x: x.handler.__name__)
             match = [
-                dependent_match(
-                    self.type_tuples[c.handler], [*args, *kwargs.items()]
-                )
+                dependent_match(self.type_tuples[c.base_handler], [*args, *kwargs.items()])
                 for c in grp
             ]
             ambiguous = len([m for m in match if m]) > 1
@@ -292,22 +299,17 @@ class MultiTypeMap(dict):
                 width = 2 * len(args) + 6
                 print(f"{color}{bullet} {lvl:{width}} {handler.__name__}")
                 co = handler.__code__
-                print(
-                    f"   {'':{width-1}}@ {co.co_filename}:{co.co_firstlineno}\033[0m"
-                )
+                print(f"   {'':{width - 1}}@ {co.co_filename}:{co.co_firstlineno}\033[0m")
             if ambiguous:
-                message += " There is ambiguity between multiple matching methods, marked '=='."
+                message += (
+                    " There is ambiguity between multiple matching methods, marked '=='."
+                )
                 finished = True
         print("Resolution:", message)
 
-    def wrap_dependent(self, tup, handlers, group, next_call):
-        handlers = list(handlers)
-        htup = [(h, self.type_tuples[h]) for h in handlers]
-        slf = (
-            "self, "
-            if inspect.getfullargspec(handlers[0]).args[0] == "self"
-            else ""
-        )
+    def wrap_dependent(self, tup, group, next_call):
+        htup = [(c.handler, self.type_tuples[c.base_handler]) for c in group]
+        slf = "self, " if inspect.getfullargspec(group[0].handler).args[0] == "self" else ""
         return generate_dependent_dispatch(
             tup,
             htup,
@@ -326,11 +328,9 @@ class MultiTypeMap(dict):
         funcs = []
         for group in reversed(results):
             handlers = [c.handler for c in group]
-            dependent = any(self.dependent[c.handler] for c in group)
+            dependent = any(self.dependent[c.base_handler] for c in group)
             if dependent:
-                nxt = self.wrap_dependent(
-                    obj_t_tup, handlers, group, funcs[-1] if funcs else None
-                )
+                nxt = self.wrap_dependent(obj_t_tup, group, funcs[-1] if funcs else None)
             elif len(group) != 1:
                 nxt = None
             else:
@@ -342,11 +342,7 @@ class MultiTypeMap(dict):
 
         parents = []
         for group, (func, codes) in zip(results, funcs):
-            tups = (
-                [obj_t_tup]
-                if not parents
-                else [(parent, *obj_t_tup) for parent in parents]
-            )
+            tups = [obj_t_tup] if not parents else [(parent, *obj_t_tup) for parent in parents]
             if func is None:
                 for tup in tups:
                     self.errors[tup] = self.key_error(obj_t_tup, group)
@@ -386,3 +382,9 @@ class MultiTypeMap(dict):
             raise self.errors[obj_t_tup]
         else:
             return self[obj_t_tup]
+
+    def __call__(self, *obj_t_tup, after=None):
+        if after:
+            return self[(after, *obj_t_tup)]
+        else:
+            return self[obj_t_tup]

ovld/types.py

@@ -1,18 +1,41 @@
+import importlib
 import inspect
 import sys
 import typing
 from dataclasses import dataclass
 from functools import partial
-from typing import Protocol, runtime_checkable
+from typing import Protocol, get_args, runtime_checkable
 
+from .codegen import Code
 from .mro import Order, TypeRelationship, subclasscheck, typeorder
+from .recode import generate_checking_code
 from .typemap import TypeMap
-from .utils import UsageError, clsstring
+from .utils import UnionType, UnionTypes, UsageError, clsstring
 
-try:
-    from types import UnionType
-except ImportError:  # pragma: no cover
-    UnionType = None
+
+def get_args(tp):
+    args = getattr(tp, "__args__", None)
+    if not isinstance(args, tuple):
+        args = ()
+    return args
+
+
+def eval_annotation(t, ctx, locals, catch=False):
+    try:
+        if isinstance(t, str):
+            if hasattr(ctx, "__globals__"):
+                glb = ctx.__globals__
+            elif hasattr(ctx, "__module__"):  # pragma: no cover
+                glb = vars(importlib.import_module(ctx.__module__))
+            else:  # pragma: no cover
+                glb = {}
+            return eval(t, glb, locals)
+        else:
+            return t
+    except Exception:  # pragma: no cover
+        if catch:
+            return None
+        raise
 
 
 class TypeNormalizer:
@@ -29,7 +52,7 @@ class TypeNormalizer:
         from .dependent import DependentType
 
         if isinstance(t, str):
-            t = eval(t, getattr(fn, "__globals__", {}))
+            t = eval_annotation(t, fn, {})
 
         if t is type:
             t = type[object]
@@ -37,6 +60,8 @@ class TypeNormalizer:
             t = object
         elif t is inspect._empty:
             t = object
+        elif t in UnionTypes:
+            return type[t]
         elif isinstance(t, typing._AnnotatedAlias):
             t = t.__origin__
 
@@ -82,7 +107,7 @@ class MetaMC(type):
         return super().__new__(T, name, (), {"_handler": handler})
 
     def __init__(cls, name, handler):
-        cls.__args__ = getattr(handler, "__args__", ())
+        cls.__args__ = get_args(handler)
 
     def codegen(cls):
         return cls._handler.codegen()
@@ -212,11 +237,15 @@ def _getcls(ref):
 
 
 class AllMC(type):
+    __bound__ = False
+
     def __type_order__(self, other):
         return Order.MORE
 
     def __is_subtype__(self, other):
-        return True
+        if not self.__bound__:
+            return True
+        return subclasscheck(self.__bound__, other) or subclasscheck(other, self.__bound__)
 
     def __is_supertype__(self, other):
         return False
@@ -227,6 +256,10 @@ class AllMC(type):
     def __isinstance__(self, other):  # pragma: no cover
         return False
 
+    def __getitem__(self, item):
+        name = getattr(item, "__name__", str(item))
+        return type(f"All[{name}]", (self,), {"__bound__": item})
+
 
 class All(metaclass=AllMC):
     """All is the empty/void/bottom type -- it acts as a subtype of all types.
@@ -304,11 +337,7 @@ def Exactly(cls, base_cls):
 @parametrized_class_check
 def StrictSubclass(cls, base_cls):
     """Match subclasses but not the base class."""
-    return (
-        isinstance(cls, type)
-        and issubclass(cls, base_cls)
-        and cls is not base_cls
-    )
+    return isinstance(cls, type) and issubclass(cls, base_cls) and cls is not base_cls
 
 
 @parametrized_class_check
@@ -317,20 +346,13 @@ class Union:
         self.__args__ = self.types = types
 
     def codegen(self):
-        from .dependent import combine, generate_checking_code
-
-        template = " or ".join("{}" for t in self.types)
-        return combine(
-            template, [generate_checking_code(t) for t in self.types]
-        )
+        return Code("($[ or ]checks)", checks=[generate_checking_code(t) for t in self.types])
 
     def __type_order__(self, other):
         if other is Union:
             return Order.LESS
         classes = self.types
-        compare = [
-            x for t in classes if (x := typeorder(t, other)) is not Order.NONE
-        ]
+        compare = [x for t in classes if (x := typeorder(t, other)) is not Order.NONE]
         if not compare:
             return Order.NONE
         elif any(x is Order.MORE or x is Order.SAME for x in compare):
@@ -368,20 +390,13 @@ class Intersection:
         self.__args__ = self.types = types
 
     def codegen(self):
-        from .dependent import combine, generate_checking_code
-
-        template = " and ".join("{}" for t in self.types)
-        return combine(
-            template, [generate_checking_code(t) for t in self.types]
-        )
+        return Code("($[ and ]checks)", checks=[generate_checking_code(t) for t in self.types])
 
     def __type_order__(self, other):
         if other is Intersection:
             return Order.LESS
         classes = self.types
-        compare = [
-            x for t in classes if (x := typeorder(t, other)) is not Order.NONE
-        ]
+        compare = [x for t in classes if (x := typeorder(t, other)) is not Order.NONE]
         if not compare:
             return Order.NONE
         elif any(x is Order.LESS or x is Order.SAME for x in compare):
@@ -427,15 +442,3 @@ class Dataclass(Protocol):
         return hasattr(subclass, "__dataclass_fields__") and hasattr(
             subclass, "__dataclass_params__"
         )
-
-
-__all__ = [
-    "Dataclass",
-    "Deferred",
-    "Exactly",
-    "HasMethod",
-    "Intersection",
-    "StrictSubclass",
-    "class_check",
-    "parametrized_class_check",
-]

ovld/utils.py

@@ -5,6 +5,15 @@ import re
 import typing
 from itertools import count
 
+try:
+    from types import UnionType
+
+    UnionTypes = (type(typing.Union[int, str]), UnionType)
+
+except ImportError:  # pragma: no cover
+    UnionType = None
+    UnionTypes = (type(typing.Union[int, str]),)
+
 
 class Named:
     """A named object.
@@ -48,13 +57,20 @@ def keyword_decorator(deco):
     return new_deco
 
 
+class CodegenInProgress(Exception):
+    pass
+
+
 class UsageError(Exception):
     pass
 
 
-class Unusable:
-    def __init__(self, message):
-        self.__message = message
+class SpecialForm:
+    def __init__(self, name, message=None):
+        self.__name = name
+        self.__message = (
+            message or f"{name}() can only be used from inside an @ovld-registered function."
+        )
 
     def __call__(self, *args, **kwargs):
         raise UsageError(self.__message)
@@ -62,6 +78,11 @@ class Unusable:
     def __getattr__(self, attr):
         raise UsageError(self.__message)
 
+    def __str__(self):
+        return f"<SpecialForm {self.__name}>"
+
+    __repr__ = __str__
+
 
 class GenericAliasMC(type):
     def __instancecheck__(cls, obj):
@@ -87,9 +108,23 @@ def clsstring(cls):
             return r
 
 
+def typemap_entry_string(cls):
+    if isinstance(cls, tuple):
+        key, typ = cls
+        return f"{key}: {clsstring(typ)}"
+    else:
+        return clsstring(cls)
+
+
+def sigstring(types):
+    return ", ".join(map(typemap_entry_string, types))
+
+
 def subtler_type(obj):
     if isinstance(obj, GenericAlias):
         return type[obj]
+    elif isinstance(obj, UnionTypes):
+        return type[obj]
     elif obj is typing.Any:
         return type[object]
     elif isinstance(obj, type):
@@ -99,7 +134,7 @@ def subtler_type(obj):
 
 
 class NameDatabase:
-    def __init__(self, default_name):
+    def __init__(self, default_name="TMP"):
         self.default_name = default_name
         self.count = count()
         self.variables = {}
@@ -109,32 +144,34 @@ class NameDatabase:
     def register(self, name):
         self.registered.add(name)
 
-    def gensym(self, desired_name):
+    def gensym(self, desired_name, value=None):
         i = 1
         name = desired_name
-        while name in self.registered:
+        while name in self.registered or (
+            name in __builtins__ and __builtins__[name] != value
+        ):
             name = f"{desired_name}{i}"
             i += 1
         self.registered.add(name)
         return name
 
-    def __getitem__(self, value):
+    def get(self, value, suggested_name=None):
         if isinstance(value, (int, float, str)):
             return repr(value)
         if id(value) in self.names:
             return self.names[id(value)]
-        name = getattr(value, "__name__", self.default_name)
-        if not re.match(string=name, pattern=r"[a-zA-Z_][a-zA-Z0-9_]+"):
-            name = self.default_name
-        name = self.gensym(name)
+        dflt = suggested_name or self.default_name
+        if (
+            isinstance(value, GenericAlias) and typing.get_origin(value) is type
+        ):  # pragma: no cover
+            name = "t_" + getattr(typing.get_args(value)[0], "__name__", dflt)
+        else:
+            name = getattr(value, "__name__", dflt)
+        if not re.match(string=name, pattern=r"^[a-zA-Z_][a-zA-Z0-9_]*$"):
+            name = dflt
+        name = self.gensym(name, value)
         self.variables[name] = value
         self.names[id(value)] = name
         return name
 
-
-__all__ = [
-    "BOOTSTRAP",
-    "MISSING",
-    "Named",
-    "keyword_decorator",
-]
+    __getitem__ = get

ovld/version.py

@@ -1 +1 @@
-version = "0.4.5"
+version = "0.5.0"

{ovld-0.4.5.dist-info → ovld-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: ovld
-Version: 0.4.5
+Version: 0.5.0
 Summary: Overloading Python functions
 Project-URL: Homepage, https://ovld.readthedocs.io/en/latest/
 Project-URL: Documentation, https://ovld.readthedocs.io/en/latest/
@@ -20,10 +20,11 @@ Fast multiple dispatch in Python, with many extra features.
 
 With ovld, you can write a version of the same function for every type signature using annotations instead of writing an awkward sequence of `isinstance` statements. Unlike Python's `singledispatch`, it works for multiple arguments.
 
-* ⚡️ **[Fast](https://ovld.readthedocs.io/en/latest/compare/#results):** `ovld` is the fastest multiple dispatch library around, by some margin.
-* 🚀 [**Variants**](https://ovld.readthedocs.io/en/latest/usage/#variants) and [**mixins**](https://ovld.readthedocs.io/en/latest/usage/#mixins) of functions and methods.
+* ⚡️ **[Fast](https://ovld.readthedocs.io/en/latest/compare/#results):** ovld is the fastest multiple dispatch library around, by some margin.
+* 🚀 [**Variants**](https://ovld.readthedocs.io/en/latest/usage/#variants), [**mixins**](https://ovld.readthedocs.io/en/latest/usage/#mixins) and [**medleys**](https://ovld.readthedocs.io/en/latest/medley) of functions and methods.
 * 🦄 **[Dependent types](https://ovld.readthedocs.io/en/latest/dependent/):** Overloaded functions can depend on more than argument types: they can depend on actual values.
-* 🔑 **Extensive:** Dispatch on functions, methods, positional arguments and even [keyword arguments](https://ovld.readthedocs.io/en/latest/usage/#keyword-arguments) (with some restrictions).
+* 🔑 **[Extensive](https://ovld.readthedocs.io/en/latest/usage/#keyword-arguments):** Dispatch on functions, methods, positional arguments and even keyword arguments (with some restrictions).
+* ⚙️ **[Codegen](https://ovld.readthedocs.io/en/latest/codegen/):** (Experimental) For advanced use cases, you can generate custom code for overloads.
 
 ## Example
 
@@ -62,7 +63,7 @@ A *variant* of an `ovld` is a copy of the `ovld`, with some methods added or cha
 
 ```python
 @add.variant
-def mul(self, x: object, y: object):
+def mul(x: object, y: object):
     return x * y
 
 assert mul([1, 2], [3, 4]) == [3, 8]
@@ -199,19 +200,64 @@ assert Two().f(1) == "an integer"
 assert Two().f("s") == "a string"
 ```
 
+## Medleys
+
+Inheriting from [`ovld.Medley`](https://ovld.readthedocs.io/en/latest/medley/) lets you combine functionality in a new way. Classes created that way are free-form medleys that you can (almost) arbitrarily combine together.
+
+All medleys are dataclasses and you must define their data fields as you would for a normal dataclass (using `dataclass.field` if needed).
+
+```python
+from ovld import Medley
+
+class Punctuator(Medley):
+    punctuation: str = "."
+
+    def __call__(self, x: str):
+        return f"{x}{self.punctuation}"
+
+class Multiplier(Medley):
+    factor: int = 3
+
+    def __call__(self, x: int):
+        return x * self.factor
+
+# You can add the classes together to merge their methods and fields using ovld
+PuMu = Punctuator + Multiplier
+f = PuMu(punctuation="!", factor=3)
+
+# You can also combine existing instances!
+f2 = Punctuator("!") + Multiplier(3)
+
+assert f("hello") == f2("hello") == "hello!"
+assert f(10) == f2(10) == 30
+
+# You can also meld medleys inplace, but only if all new fields have defaults
+class Total(Medley):
+    pass
+
+Total.extend(Punctuator, Multiplier)
+f3 = Total(punctuation="!", factor=3)
+```
+
+
+# Code generation
+
+(Experimental) For advanced use cases, you can generate custom code for type checkers or overloads. [See here](https://ovld.readthedocs.io/en/latest/codegen/).
+
+
 # Benchmarks
 
 `ovld` is pretty fast: the overhead is comparable to `isinstance` or `match`, and only 2-3x slower when dispatching on `Literal` types. Compared to other multiple dispatch libraries, it has 1.5x to 100x less overhead.
 
 Time relative to the fastest implementation (1.00) (lower is better).
 
-| Benchmark | custom | [ovld](https://github.com/breuleux/ovld) | [plum](https://github.com/beartype/plum) | [multim](https://github.com/coady/multimethod) | [multid](https://github.com/mrocklin/multipledispatch/) | [runtype](https://github.com/erezsh/runtype) | [fastcore](https://github.com/fastai/fastcore) | [sd](https://docs.python.org/3/library/functools.html#functools.singledispatch) |
-| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
-|[trivial](https://github.com/breuleux/ovld/tree/master/benchmarks/test_trivial.py)|1.45|1.00|3.32|4.63|2.04|2.41|51.93|1.91|
-|[multer](https://github.com/breuleux/ovld/tree/master/benchmarks/test_multer.py)|1.13|1.00|11.05|4.53|8.31|2.19|46.74|7.32|
-|[add](https://github.com/breuleux/ovld/tree/master/benchmarks/test_add.py)|1.08|1.00|3.73|5.21|2.37|2.79|59.31|x|
-|[ast](https://github.com/breuleux/ovld/tree/master/benchmarks/test_ast.py)|1.00|1.08|23.14|3.09|1.68|1.91|28.39|1.66|
-|[calc](https://github.com/breuleux/ovld/tree/master/benchmarks/test_calc.py)|1.00|1.23|54.61|29.32|x|x|x|x|
-|[regexp](https://github.com/breuleux/ovld/tree/master/benchmarks/test_regexp.py)|1.00|1.87|19.18|x|x|x|x|x|
-|[fib](https://github.com/breuleux/ovld/tree/master/benchmarks/test_fib.py)|1.00|3.30|444.31|125.77|x|x|x|x|
-|[tweaknum](https://github.com/breuleux/ovld/tree/master/benchmarks/test_tweaknum.py)|1.00|2.09|x|x|x|x|x|x|
+| Benchmark | custom | [ovld](https://github.com/breuleux/ovld) | [plum](https://github.com/beartype/plum) | [multim](https://github.com/coady/multimethod) | [multid](https://github.com/mrocklin/multipledispatch) | [runtype](https://github.com/erezsh/runtype) | [sd](https://docs.python.org/3/library/functools.html#functools.singledispatch) |
+| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
+|[trivial](https://github.com/breuleux/ovld/tree/master/benchmarks/test_trivial.py)|1.45|1.00|3.32|4.63|2.04|2.41|1.91|
+|[multer](https://github.com/breuleux/ovld/tree/master/benchmarks/test_multer.py)|1.13|1.00|11.05|4.53|8.31|2.19|7.32|
+|[add](https://github.com/breuleux/ovld/tree/master/benchmarks/test_add.py)|1.08|1.00|3.73|5.21|2.37|2.79|x|
+|[ast](https://github.com/breuleux/ovld/tree/master/benchmarks/test_ast.py)|1.00|1.08|23.14|3.09|1.68|1.91|1.66|
+|[calc](https://github.com/breuleux/ovld/tree/master/benchmarks/test_calc.py)|1.00|1.23|54.61|29.32|x|x|x|
+|[regexp](https://github.com/breuleux/ovld/tree/master/benchmarks/test_regexp.py)|1.00|1.87|19.18|x|x|x|x|
+|[fib](https://github.com/breuleux/ovld/tree/master/benchmarks/test_fib.py)|1.00|3.30|444.31|125.77|x|x|x|
+|[tweaknum](https://github.com/breuleux/ovld/tree/master/benchmarks/test_tweaknum.py)|1.00|2.09|x|x|x|x|x|

ovld-0.5.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+ovld/__init__.py,sha256=JuCM8Sj65gobV0KYyLr95cSI23Pi6RYZ7X3_F3fdsSw,1821
+ovld/abc.py,sha256=4qpZyYwI8dWgY1Oiv5FhdKg2uzNcyWxIpGmGJVcjXrs,1177
+ovld/codegen.py,sha256=0ZZdXw-nn9t52BX93GX6zwTeBB_wCmc5OxSk37sBrVU,9112
+ovld/core.py,sha256=uAnzuxa3hZjZSbCs3FW_0uR9qQlY-HZhgKpDTyvp59Y,17346
+ovld/dependent.py,sha256=h3j4oQYTQfGqMzggWlLV6TpojX_GtYRFWAO0GcMB0Zs,9085
+ovld/medley.py,sha256=Gin0EYeuQ7qZdDKNFFIwBY4o8W-VT5pl2bP8GCSopU4,12136
+ovld/mro.py,sha256=nqe9jHvsaLu-CfXoP2f7tHg5_8IkcESWMnBmvr4XGIo,4605
+ovld/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ovld/recode.py,sha256=AoNgJw75RAlfSBeFL5-UeB_T7wN_Xqzuahr9VhqC_yI,16126
+ovld/signatures.py,sha256=Q8JucSOun0ESGx14aWtHtBzLEiM6FxY5HP3imyqXoDo,8984
+ovld/typemap.py,sha256=5Pro1Ee60fH4L7NW7k5nbN5EfDygA0LFHcI6o3mCagI,13596
+ovld/types.py,sha256=0hkhAR5_5793NABdrM-fP1dSJBhYof85FILKqVP2YMg,13392
+ovld/utils.py,sha256=q2zFrK3OifhDu4SsVyLP4WKIp8FDDcJmLwMEUoWHS6c,4227
+ovld/version.py,sha256=-beU6vQRolzltfD0fQR6KSzR5yUgbfwYBlKbvzktqbg,18
+ovld-0.5.0.dist-info/METADATA,sha256=HzSeUKkJrJRUbPJZqw1XZpkW58EKhgl6GOi32CaPPcw,9276
+ovld-0.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ovld-0.5.0.dist-info/licenses/LICENSE,sha256=cSwNTIzd1cbI89xt3PeZZYJP2y3j8Zus4bXgo4svpX8,1066
+ovld-0.5.0.dist-info/RECORD,,

{ovld-0.4.5.dist-info → ovld-0.5.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.25.0
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any

ovld-0.4.5.dist-info/RECORD

@@ -1,14 +0,0 @@
-ovld/__init__.py,sha256=IVzs4_9skMa_UGZsGT7Ra_dIxj7KKNlV77XxlqcS6ow,1446
-ovld/abc.py,sha256=4qpZyYwI8dWgY1Oiv5FhdKg2uzNcyWxIpGmGJVcjXrs,1177
-ovld/core.py,sha256=MtRcJNhMwsix2Y7zP1fQS-taCy_t0bqkjHQdLF8WE8E,25719
-ovld/dependent.py,sha256=nyrkkmgxGjcHnZjKqbk7_g4_D91SYfYTPIE32LOvC9o,10184
-ovld/mro.py,sha256=0cJK_v-POCiuwjluwf8fWeQ3G-2chEUv3KYe57GC61Q,4552
-ovld/recode.py,sha256=bwsdM-TPpSQEmJhv8G30yDLrF8_I5wyTXpITMCC1W9k,17961
-ovld/typemap.py,sha256=PH5dy8ddVCcqj2TkQbgsM7fmCdHsJT9WGXFPn4JZsCA,13131
-ovld/types.py,sha256=EZNv8pThbo47KBULYM3R0R3sM2C5LC4DWraXZImkiNs,12877
-ovld/utils.py,sha256=jrrG_BqjI3W7x285nLuYiy5ui9LbNltblFVTlOWHYiU,3123
-ovld/version.py,sha256=GzDw9yI90LiIOYlw5gZBih8gPe3URgiM0vAFi2-I3ro,18
-ovld-0.4.5.dist-info/METADATA,sha256=AM7DiTgyU53Z0A7s8MIJJ3t1rgk1pxf3uqPU20kVO6o,7833
-ovld-0.4.5.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-ovld-0.4.5.dist-info/licenses/LICENSE,sha256=cSwNTIzd1cbI89xt3PeZZYJP2y3j8Zus4bXgo4svpX8,1066
-ovld-0.4.5.dist-info/RECORD,,