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

ovld/dependent.py

@@ -1,12 +1,20 @@
 import inspect
 import re
-from dataclasses import dataclass
+from collections.abc import Callable as _Callable
+from collections.abc import Mapping, Sequence
+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,
+    clsstring,
     normalize_type,
     subclasscheck,
     typeorder,
@@ -15,10 +23,17 @@ from .types import (
 _current = count()
 
 
-@dataclass
+def generate_checking_code(typ):
+    if hasattr(typ, "codegen"):
+        return typ.codegen()
+    else:
+        return CodeGen("isinstance({arg}, {this})", this=typ)
+
+
 class CodeGen:
-    template: str
-    substitutions: dict
+    def __init__(self, template, substitutions={}, **substitutions_kw):
+        self.template = template
+        self.substitutions = {**substitutions, **substitutions_kw}
 
     def mangle(self):
         renamings = {
@@ -30,10 +45,7 @@ class CodeGen:
             for k, newk in renamings.items()
             if k in self.substitutions
         }
-        return CodeGen(
-            template=self.template.format(**renamings),
-            substitutions=new_subs,
-        )
+        return CodeGen(self.template.format(**renamings), new_subs)
 
 
 def combine(master_template, args):
@@ -46,9 +58,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
@@ -64,7 +89,7 @@ class DependentType:
         raise NotImplementedError()
 
     def codegen(self):
-        return CodeGen("{this}.check({arg})", {"this": self})
+        return CodeGen("{this}.check({arg})", this=self)
 
     def __type_order__(self, other):
         if isinstance(other, DependentType):
@@ -95,18 +120,19 @@ class DependentType:
         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):
@@ -114,7 +140,12 @@ class ParametrizedDependentType(DependentType):
         super().__init__(
             self.default_bound(*parameters) if bound is None else bound
         )
-        self.parameters = parameters
+        self.__args__ = self.parameters = parameters
+        self.__origin__ = None
+        self.__post_init__()
+
+    def __post_init__(self):
+        pass
 
     @property
     def parameter(self):
@@ -137,18 +168,24 @@ 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__
 
 
 class FuncDependentType(ParametrizedDependentType):
     def default_bound(self, *_):
-        fn = type(self).func
-        return normalize_type(
-            list(inspect.signature(fn).parameters.values())[0].annotation, fn
-        )
+        return self._default_bound
 
     def __lt__(self, other):
         if len(self.parameters) != len(other.parameters):
@@ -167,10 +204,43 @@ class FuncDependentType(ParametrizedDependentType):
         return type(self).func(value, *self.parameters)
 
 
-def dependent_check(fn):
-    t = type(fn.__name__, (FuncDependentType,), {"func": fn})
-    if len(inspect.signature(fn).parameters) == 1:
-        t = t()
+def dependent_check(fn=None, bound_is_name=False):
+    if fn is None:
+        return partial(dependent_check, bound_is_name=bound_is_name)
+
+    if isinstance(fn, type):
+        params = inspect.signature(fn.check).parameters
+        bound = normalize_type(
+            list(inspect.signature(fn.check).parameters.values())[1].annotation,
+            fn.check,
+        )
+        t = type(
+            fn.__name__,
+            (FuncDependentType,),
+            {
+                "bound_is_name": bound_is_name,
+                "_default_bound": bound,
+                **vars(fn),
+            },
+        )
+
+    else:
+        params = inspect.signature(fn).parameters
+        bound = normalize_type(
+            list(inspect.signature(fn).parameters.values())[0].annotation, fn
+        )
+        t = type(
+            fn.__name__,
+            (FuncDependentType,),
+            {
+                "func": fn,
+                "bound_is_name": bound_is_name,
+                "_default_bound": bound,
+            },
+        )
+        if len(params) == 1:
+            t = t()
+
     return t
 
 
@@ -192,13 +262,82 @@ class Equals(ParametrizedDependentType):
 
     def codegen(self):
         if len(self.parameters) == 1:
-            return CodeGen("({arg} == {p})", {"p": self.parameter})
+            return CodeGen("({arg} == {p})", p=self.parameter)
         else:
-            return CodeGen("({arg} in {ps})", {"ps": self.parameters})
+            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 HasKeys(value: Mapping, *keys):
+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 HasKey(value: Mapping, *keys):
     return all(k in value for k in keys)
 
 
@@ -213,8 +352,15 @@ def EndsWith(value: str, suffix):
 
 
 @dependent_check
-def Regexp(value: str, regexp):
-    return bool(re.search(pattern=regexp, string=value))
+class Regexp:
+    def __post_init__(self):
+        self.rx = re.compile(self.parameter)
+
+    def check(self, value: str):
+        return bool(self.rx.search(value))
+
+    def codegen(self):
+        return CodeGen("bool({rx}.search({arg}))", rx=self.rx)
 
 
 class Dependent:
@@ -225,44 +371,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
 
@@ -275,7 +383,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,6 +18,18 @@ 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:
@@ -26,16 +38,6 @@ class TypeRelationship:
     subtype: bool = NotImplemented
 
 
-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.
 
@@ -60,30 +62,14 @@ def typeorder(t1, t2):
     ):
         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
@@ -92,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
@@ -103,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
@@ -145,17 +121,8 @@ def subclasscheck(t1, t2):
     ):
         return result
 
-    o1 = getattr(t1, "__origin__", None)
-    o2 = getattr(t2, "__origin__", None)
-
-    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
@@ -165,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(
@@ -179,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):