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

ovld/__init__.py

@@ -1,5 +1,6 @@
 from typing import TYPE_CHECKING
 
+from . import abc  # noqa: F401
 from .core import (
     Ovld,
     OvldBase,
@@ -15,6 +16,11 @@ from .dependent import (
     ParametrizedDependentType,
     dependent_check,
 )
+from .mro import (
+    TypeRelationship,
+    subclasscheck,
+    typeorder,
+)
 from .recode import call_next, recurse
 from .typemap import (
     MultiTypeMap,
@@ -66,6 +72,9 @@ __all__ = [
     "Intersection",
     "StrictSubclass",
     "class_check",
+    "subclasscheck",
+    "typeorder",
+    "TypeRelationship",
     "parametrized_class_check",
     "keyword_decorator",
     "call_next",

ovld/abc.py

@@ -0,0 +1,48 @@
+import typing
+from collections.abc import Callable, Collection, Mapping, Sequence
+
+from .dependent import Callable as OvldCallable
+from .dependent import (
+    CollectionFastCheck,
+    Equals,
+    MappingFastCheck,
+    ProductType,
+    SequenceFastCheck,
+)
+from .types import normalize_type
+
+
+@normalize_type.register_generic(typing.Literal)
+def _(self, t, fn):
+    return Equals[t.__args__]
+
+
+@normalize_type.register_generic(tuple)
+def _(self, t, fn):
+    args = tuple(self(arg, fn) for arg in t.__args__)
+    return ProductType[args]
+
+
+@normalize_type.register_generic(Sequence)
+def _(self, t, fn):
+    args = tuple(self(arg, fn) for arg in t.__args__)
+    return SequenceFastCheck[args]
+
+
+@normalize_type.register_generic(Collection)
+def _(self, t, fn):
+    args = tuple(self(arg, fn) for arg in t.__args__)
+    return CollectionFastCheck[args]
+
+
+@normalize_type.register_generic(Mapping)
+def _(self, t, fn):
+    args = tuple(self(arg, fn) for arg in t.__args__)
+    return MappingFastCheck[args]
+
+
+@normalize_type.register_generic(Callable)
+def _(self, t, fn):
+    *at, rt = t.__args__
+    at = tuple(self(arg, fn) for arg in at)
+    return OvldCallable[at, self(rt, fn)]

ovld/core.py

@@ -16,9 +16,9 @@ from .recode import (
     generate_dispatch,
     rename_function,
 )
-from .typemap import MultiTypeMap, is_type_of_type
-from .types import normalize_type
-from .utils import UsageError, keyword_decorator
+from .typemap import MultiTypeMap
+from .types import clsstring, normalize_type
+from .utils import UsageError, keyword_decorator, subtler_type
 
 _current_id = itertools.count()
 
@@ -80,6 +80,7 @@ class Arginfo:
 @dataclass(frozen=True)
 class Signature:
     types: tuple
+    return_type: type
     req_pos: int
     max_pos: int
     req_names: frozenset
@@ -139,6 +140,7 @@ class Signature:
 
         return cls(
             types=tuple(typelist),
+            return_type=normalize_type(sig.return_annotation, fn),
             req_pos=req_pos,
             max_pos=max_pos,
             req_names=frozenset(req_names),
@@ -149,28 +151,16 @@ class Signature:
         )
 
 
-def clsstring(cls):
-    if cls is object:
-        return "*"
-    elif isinstance(cls, tuple):
+def typemap_entry_string(cls):
+    if isinstance(cls, tuple):
         key, typ = cls
         return f"{key}: {clsstring(typ)}"
-    elif is_type_of_type(cls):
-        arg = clsstring(cls.__args__[0])
-        return f"type[{arg}]"
-    elif hasattr(cls, "__origin__"):
-        if cls.__origin__ is typing.Union:
-            return "|".join(map(clsstring, cls.__args__))
-        else:
-            return repr(cls)
-    elif hasattr(cls, "__name__"):
-        return cls.__name__
     else:
-        return repr(cls)
+        return clsstring(cls)
 
 
 def sigstring(types):
-    return ", ".join(map(clsstring, types))
+    return ", ".join(map(typemap_entry_string, types))
 
 
 class ArgumentAnalyzer:
@@ -277,9 +267,7 @@ class ArgumentAnalyzer:
         )
 
     def lookup_for(self, key):
-        return (
-            "self.map.transform" if key in self.complex_transforms else "type"
-        )
+        return subtler_type if key in self.complex_transforms else type
 
 
 class _Ovld:
@@ -473,7 +461,7 @@ class _Ovld:
     @_compile_first
     def resolve(self, *args):
         """Find the correct method to call for the given arguments."""
-        return self.map[tuple(map(self.map.transform, args))]
+        return self.map[tuple(map(subtler_type, args))]
 
     def register_signature(self, sig, orig_fn):
         """Register a function for the given signature."""
@@ -577,7 +565,7 @@ class _Ovld:
 
         This should be replaced by an auto-generated function.
         """
-        key = tuple(map(self.map.transform, args))
+        key = tuple(map(subtler_type, args))
         method = self.map[key]
         return method(*args)
 
@@ -586,7 +574,7 @@ class _Ovld:
     def next(self, *args):
         """Call the next matching method after the caller, in terms of priority or specificity."""
         fr = sys._getframe(1)
-        key = (fr.f_code, *map(self.map.transform, args))
+        key = (fr.f_code, *map(subtler_type, args))
         method = self.map[key]
         return method(*args)
 
@@ -631,20 +619,20 @@ class OvldCall:
     def next(self, *args):
         """Call the next matching method after the caller, in terms of priority or specificity."""
         fr = sys._getframe(1)
-        key = (fr.f_code, *map(self.map.transform, args))
+        key = (fr.f_code, *map(subtler_type, args))
         method = self.map[key]
         return method(self.obj, *args)
 
     def resolve(self, *args):
         """Find the right method to call for the given arguments."""
-        return self.map[tuple(map(self.map.transform, args))].__get__(self.obj)
+        return self.map[tuple(map(subtler_type, args))].__get__(self.obj)
 
     def __call__(self, *args):  # pragma: no cover
         """Call this overloaded function.
 
         This should be replaced by an auto-generated function.
         """
-        key = tuple(map(self.map.transform, args))
+        key = tuple(map(subtler_type, args))
         method = self.map[key]
         return method(self.obj, *args)
 

ovld/dependent.py

@@ -1,13 +1,21 @@
 import inspect
 import re
+from collections.abc import Callable as _Callable
+from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
+from functools import partial
 from itertools import count
-from typing import TYPE_CHECKING, Any, Mapping, TypeVar, Union
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Collection,
+    TypeVar,
+)
 
 from .types import (
     Intersection,
     Order,
-    TypeRelationship,
+    clsstring,
     normalize_type,
     subclasscheck,
     typeorder,
@@ -16,6 +24,13 @@ from .types import (
 _current = count()
 
 
+def generate_checking_code(typ):
+    if hasattr(typ, "codegen"):
+        return typ.codegen()
+    else:
+        return CodeGen("isinstance({arg}, {this})", {"this": typ})
+
+
 @dataclass
 class CodeGen:
     template: str
@@ -47,9 +62,22 @@ def combine(master_template, args):
     return CodeGen(master_template.format(*fmts), subs)
 
 
-class DependentType:
+def is_dependent(t):
+    if isinstance(t, DependentType):
+        return True
+    elif any(is_dependent(subt) for subt in getattr(t, "__args__", ())):
+        return True
+    return False
+
+
+class DependentType(type):
     exclusive_type = False
     keyable_type = False
+    bound_is_name = False
+
+    def __new__(cls, *args, **kwargs):
+        value = super().__new__(cls, cls.__name__, (), {})
+        return value
 
     def __init__(self, bound):
         self.bound = bound
@@ -67,39 +95,48 @@ class DependentType:
     def codegen(self):
         return CodeGen("{this}.check({arg})", {"this": self})
 
-    def __typeorder__(self, other):
+    def __type_order__(self, other):
         if isinstance(other, DependentType):
             order = typeorder(self.bound, other.bound)
             if order is Order.SAME:
                 # It isn't fully deterministic which of these will be called
                 # because of set ordering between the types we compare
                 if self < other:  # pragma: no cover
-                    return TypeRelationship(Order.LESS, matches=False)
+                    return Order.LESS
                 elif other < self:  # pragma: no cover
-                    return TypeRelationship(Order.MORE, matches=False)
+                    return Order.MORE
                 else:
-                    return TypeRelationship(Order.NONE, matches=False)
+                    return Order.NONE
             else:  # pragma: no cover
-                return TypeRelationship(order, matches=False)
-        elif (matches := subclasscheck(other, self.bound)) or subclasscheck(
+                return order
+        elif subclasscheck(other, self.bound) or subclasscheck(
             self.bound, other
         ):
-            return TypeRelationship(Order.LESS, matches=matches)
+            return Order.LESS
         else:
-            return TypeRelationship(Order.NONE, matches=False)
+            return Order.NONE
+
+    def __is_supertype__(self, other):
+        if isinstance(other, DependentType):
+            return False
+        elif subclasscheck(other, self.bound):
+            return True
+        else:
+            return False
+
+    def __instancecheck__(self, other):
+        return isinstance(other, self.bound) and self.check(other)
 
     def __lt__(self, other):
         return False
 
-    def __or__(self, other):
-        if not isinstance(other, DependentType):
-            return NotImplemented
-        return Or(self, other)
-
     def __and__(self, other):
-        if not isinstance(other, DependentType):
-            return NotImplemented
-        return And(self, other)
+        return Intersection[self, other]
+
+    def __rand__(self, other):
+        return Intersection[other, self]
+
+    __repr__ = __str__ = clsstring
 
 
 class ParametrizedDependentType(DependentType):
@@ -107,7 +144,7 @@ class ParametrizedDependentType(DependentType):
         super().__init__(
             self.default_bound(*parameters) if bound is None else bound
         )
-        self.parameters = parameters
+        self.__args__ = self.parameters = parameters
 
     @property
     def parameter(self):
@@ -130,8 +167,17 @@ class ParametrizedDependentType(DependentType):
         return hash(self.parameters) ^ hash(self.bound)
 
     def __str__(self):
-        params = ", ".join(map(repr, self.parameters))
-        return f"{type(self).__name__}({params})"
+        if self.bound_is_name:
+            origin = self.bound
+            bound = ""
+        else:
+            origin = self
+            if self.bound != self.default_bound(*self.parameters):
+                bound = f" < {clsstring(self.bound)}"
+            else:
+                bound = ""
+        args = ", ".join(map(clsstring, self.__args__))
+        return f"{origin.__name__}[{args}]{bound}"
 
     __repr__ = __str__
 
@@ -160,8 +206,14 @@ class FuncDependentType(ParametrizedDependentType):
         return type(self).func(value, *self.parameters)
 
 
-def dependent_check(fn):
-    t = type(fn.__name__, (FuncDependentType,), {"func": fn})
+def dependent_check(fn=None, bound_is_name=False):
+    if fn is None:
+        return partial(dependent_check, bound_is_name=bound_is_name)
+    t = type(
+        fn.__name__,
+        (FuncDependentType,),
+        {"func": fn, "bound_is_name": bound_is_name},
+    )
     if len(inspect.signature(fn).parameters) == 1:
         t = t()
     return t
@@ -190,8 +242,77 @@ class Equals(ParametrizedDependentType):
             return CodeGen("({arg} in {ps})", {"ps": self.parameters})
 
 
+class ProductType(ParametrizedDependentType):
+    bound_is_name = True
+
+    def default_bound(self, *subtypes):
+        return tuple
+
+    def check(self, value):
+        return (
+            isinstance(value, tuple)
+            and len(value) == len(self.parameters)
+            and all(isinstance(x, t) for x, t in zip(value, self.parameters))
+        )
+
+    def codegen(self):
+        checks = ["len({arg}) == {n}"]
+        params = {"n": len(self.parameters)}
+        for i, p in enumerate(self.parameters):
+            checks.append(f"isinstance({{arg}}[{i}], {{p{i}}})")
+            params[f"p{i}"] = p
+        return CodeGen(" and ".join(checks), params)
+
+    def __type_order__(self, other):
+        if isinstance(other, ProductType):
+            if len(other.parameters) == len(self.parameters):
+                return Order.merge(
+                    typeorder(a, b)
+                    for a, b in zip(self.parameters, other.parameters)
+                )
+            else:
+                return Order.NONE
+        else:
+            return NotImplemented
+
+
+@dependent_check(bound_is_name=True)
+def SequenceFastCheck(value: Sequence, typ):
+    return not value or isinstance(value[0], typ)
+
+
+@dependent_check(bound_is_name=True)
+def CollectionFastCheck(value: Collection, typ):
+    for x in value:
+        return isinstance(x, typ)
+    else:
+        return True
+
+
+@dependent_check(bound_is_name=True)
+def MappingFastCheck(value: Mapping, kt, vt):
+    if not value:
+        return True
+    for k in value:
+        break
+    return isinstance(k, kt) and isinstance(value[k], vt)
+
+
+@dependent_check
+def Callable(fn: _Callable, argt, rett):
+    from .core import Signature
+
+    sig = Signature.extract(fn)
+    return (
+        sig.max_pos >= len(argt) >= sig.req_pos
+        and not sig.req_names
+        and all(subclasscheck(t1, t2) for t1, t2 in zip(argt, sig.types))
+        and subclasscheck(sig.return_type, rett)
+    )
+
+
 @dependent_check
-def HasKeys(value: Mapping, *keys):
+def HasKey(value: Mapping, *keys):
     return all(k in value for k in keys)
 
 
@@ -218,44 +339,6 @@ class Dependent:
         return dt.with_bound(bound)
 
 
-class Or(DependentType):
-    def __init__(self, *types, bound=None):
-        self.types = types
-        super().__init__(bound or self.default_bound())
-
-    def default_bound(self):
-        return Union[tuple([t.bound for t in self.types])]
-
-    def codegen(self):
-        template = " or ".join("{}" for t in self.types)
-        return combine(template, [t.codegen() for t in self.types])
-
-    def check(self, value):
-        return any(t.check(value) for t in self.types)
-
-
-class And(DependentType):
-    def __init__(self, *types, bound=None):
-        self.types = types
-        super().__init__(bound or self.default_bound())
-
-    def default_bound(self):
-        bounds = frozenset(t.bound for t in self.types)
-        return Intersection[tuple(bounds)]
-
-    def codegen(self):
-        template = " and ".join("{}" for t in self.types)
-        return combine(template, [t.codegen() for t in self.types])
-
-    def check(self, value):
-        return all(t.check(value) for t in self.types)
-
-    def __str__(self):
-        return " & ".join(map(repr, self.types))
-
-    __repr__ = __str__
-
-
 if TYPE_CHECKING:  # pragma: no cover
     from typing import Annotated, TypeAlias
 
@@ -268,7 +351,7 @@ __all__ = [
     "Dependent",
     "DependentType",
     "Equals",
-    "HasKeys",
+    "HasKey",
     "StartsWith",
     "EndsWith",
     "dependent_check",

ovld/mro.py

@@ -1,7 +1,7 @@
-import typing
 from dataclasses import dataclass
 from enum import Enum
 from graphlib import TopologicalSorter
+from typing import get_args, get_origin
 
 
 class Order(Enum):
@@ -18,21 +18,24 @@ class Order(Enum):
         else:
             return self
 
+    @staticmethod
+    def merge(orders):
+        orders = set(orders)
+        if orders == {Order.SAME}:
+            return Order.SAME
+        elif not (orders - {Order.LESS, Order.SAME}):
+            return Order.LESS
+        elif not (orders - {Order.MORE, Order.SAME}):
+            return Order.MORE
+        else:
+            return Order.NONE
+
 
 @dataclass
 class TypeRelationship:
     order: Order
-    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
+    supertype: bool = NotImplemented
+    subtype: bool = NotImplemented
 
 
 def typeorder(t1, t2):
@@ -48,44 +51,25 @@ def typeorder(t1, t2):
     if t1 == t2:
         return Order.SAME
 
-    t1 = getattr(t1, "__proxy_for__", t1)
-    t2 = getattr(t2, "__proxy_for__", t2)
-
     if (
-        hasattr(t1, "__typeorder__")
-        and (result := t1.__typeorder__(t2)) is not NotImplemented
+        hasattr(t1, "__type_order__")
+        and (result := t1.__type_order__(t2)) is not NotImplemented
     ):
-        return result.order
+        return result
     elif (
-        hasattr(t2, "__typeorder__")
-        and (result := t2.__typeorder__(t1)) is not NotImplemented
+        hasattr(t2, "__type_order__")
+        and (result := t2.__type_order__(t1)) is not NotImplemented
     ):
-        return result.order.opposite()
+        return result.opposite()
 
-    o1 = getattr(t1, "__origin__", None)
-    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
-        ]
-        if not compare:
-            return Order.NONE
-        elif any(x is Order.LESS or x is Order.SAME for x in compare):
-            return Order.LESS
-        else:
-            return Order.MORE
-
-    if o1 is typing.Union:
-        return typeorder(t2, t1).opposite()
+    o1 = get_origin(t1)
+    o2 = get_origin(t2)
 
     if o2 and not o1:
         return typeorder(t2, t1).opposite()
 
     if o1:
-        if not o2:  # or getattr(t2, "__args__", None) is None:
+        if not o2:
             order = typeorder(o1, t2)
             if order is order.SAME:
                 order = order.LESS
@@ -94,8 +78,8 @@ def typeorder(t1, t2):
         if (order := typeorder(o1, o2)) is not Order.SAME:
             return order
 
-        args1 = getattr(t1, "__args__", ())
-        args2 = getattr(t2, "__args__", ())
+        args1 = get_args(t1)
+        args2 = get_args(t2)
 
         if args1 and not args2:
             return Order.LESS
@@ -105,20 +89,10 @@ def typeorder(t1, t2):
             return Order.NONE
 
         ords = [typeorder(a1, a2) for a1, a2 in zip(args1, args2)]
-        if Order.MORE in ords and Order.LESS in ords:
-            return Order.NONE
-        elif Order.NONE in ords:
-            return Order.NONE
-        elif Order.MORE in ords:
-            return Order.MORE
-        elif Order.LESS in ords:
-            return Order.LESS
-        else:  # pragma: no cover
-            # Not sure when t1 != t2 and that happens
-            return Order.SAME
+        return Order.merge(ords)
 
-    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
@@ -135,26 +109,20 @@ def subclasscheck(t1, t2):
     if t1 == t2:
         return True
 
-    t1 = getattr(t1, "__proxy_for__", t1)
-    t2 = getattr(t2, "__proxy_for__", t2)
-
     if (
-        hasattr(t2, "__typeorder__")
-        and (result := t2.__typeorder__(t1)) is not NotImplemented
+        hasattr(t2, "__is_supertype__")
+        and (result := t2.__is_supertype__(t1)) is not NotImplemented
     ):
-        return result.matches
+        return result
 
-    o1 = getattr(t1, "__origin__", None)
-    o2 = getattr(t2, "__origin__", None)
+    if (
+        hasattr(t1, "__is_subtype__")
+        and (result := t1.__is_subtype__(t2)) is not NotImplemented
+    ):
+        return result
 
-    if o2 is typing.Union:
-        return t1 is typing.Union or any(
-            subclasscheck(t1, t) for t in t2.__args__
-        )
-    elif o1 is typing.Union:
-        return t2 is typing.Union or all(
-            subclasscheck(t, t2) for t in t1.__args__
-        )
+    o1 = get_origin(t1)
+    o2 = get_origin(t2)
 
     if not isinstance(o1, type):
         o1 = None
@@ -164,12 +132,12 @@ def subclasscheck(t1, t2):
     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:
-                args1 = getattr(t1, "__args__", ())
-                args2 = getattr(t2, "__args__", ())
+                args1 = get_args(t1)
+                args2 = get_args(t2)
                 if len(args1) != len(args2):
                     return False
                 return all(
@@ -178,7 +146,10 @@ def subclasscheck(t1, t2):
         else:
             return False
     else:
-        return _issubclass(t1, t2)
+        try:
+            return issubclass(t1, t2)
+        except TypeError:
+            return False
 
 
 def sort_types(cls, avail):