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

ovld/dependent.py

@@ -0,0 +1,275 @@
+import inspect
+import re
+from dataclasses import dataclass
+from itertools import count
+from typing import TYPE_CHECKING, Any, Mapping, TypeVar, Union
+
+from .types import (
+    Intersection,
+    Order,
+    TypeRelationship,
+    normalize_type,
+    subclasscheck,
+    typeorder,
+)
+
+_current = count()
+
+
+@dataclass
+class CodeGen:
+    template: str
+    substitutions: dict
+
+    def mangle(self):
+        renamings = {
+            k: f"{{{k}__{next(_current)}}}" for k in self.substitutions
+        }
+        renamings["arg"] = "{arg}"
+        new_subs = {
+            newk[1:-1]: self.substitutions[k]
+            for k, newk in renamings.items()
+            if k in self.substitutions
+        }
+        return CodeGen(
+            template=self.template.format(**renamings),
+            substitutions=new_subs,
+        )
+
+
+def combine(master_template, args):
+    fmts = []
+    subs = {}
+    for cg in args:
+        mangled = cg.mangle()
+        fmts.append(mangled.template)
+        subs.update(mangled.substitutions)
+    return CodeGen(master_template.format(*fmts), subs)
+
+
+class DependentType:
+    exclusive_type = False
+    keyable_type = False
+
+    def __init__(self, bound):
+        self.bound = bound
+
+    def __class_getitem__(cls, item):
+        items = (item,) if not isinstance(item, tuple) else item
+        return cls(*items)
+
+    def with_bound(self, new_bound):  # pragma: no cover
+        return type(self)(new_bound)
+
+    def check(self, value):  # pragma: no cover
+        raise NotImplementedError()
+
+    def codegen(self):
+        return CodeGen("{this}.check({arg})", {"this": self})
+
+    def __typeorder__(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)
+                elif other < self:  # pragma: no cover
+                    return TypeRelationship(Order.MORE, matches=False)
+                else:
+                    return TypeRelationship(Order.NONE, matches=False)
+            else:  # pragma: no cover
+                return TypeRelationship(order, matches=False)
+        elif (matches := subclasscheck(other, self.bound)) or subclasscheck(
+            self.bound, other
+        ):
+            return TypeRelationship(Order.LESS, matches=matches)
+        else:
+            return TypeRelationship(Order.NONE, matches=False)
+
+    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)
+
+
+class ParametrizedDependentType(DependentType):
+    def __init__(self, *parameters, bound=None):
+        super().__init__(
+            self.default_bound(*parameters) if bound is None else bound
+        )
+        self.parameters = parameters
+
+    @property
+    def parameter(self):
+        return self.parameters[0]
+
+    def default_bound(self, *parameters):
+        return None
+
+    def with_bound(self, new_bound):
+        return type(self)(*self.parameters, bound=new_bound)
+
+    def __eq__(self, other):
+        return (
+            type(self) is type(other)
+            and self.parameters == other.parameters
+            and self.bound == other.bound
+        )
+
+    def __hash__(self):
+        return hash(self.parameters) ^ hash(self.bound)
+
+    def __str__(self):
+        params = ", ".join(map(repr, self.parameters))
+        return f"{type(self).__name__}({params})"
+
+    __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
+        )
+
+    def __lt__(self, other):
+        if len(self.parameters) != len(other.parameters):
+            return False
+        p1g = sum(
+            p1 is Any and p2 is not Any
+            for p1, p2 in zip(self.parameters, other.parameters)
+        )
+        p2g = sum(
+            p2 is Any and p1 is not Any
+            for p1, p2 in zip(self.parameters, other.parameters)
+        )
+        return p2g and not p1g
+
+    def check(self, value):
+        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()
+    return t
+
+
+class Equals(ParametrizedDependentType):
+    keyable_type = True
+
+    def default_bound(self, *parameters):
+        return type(parameters[0])
+
+    def check(self, value):
+        return value in self.parameters
+
+    @classmethod
+    def keygen(cls):
+        return "{arg}"
+
+    def get_keys(self):
+        return [self.parameter]
+
+    def codegen(self):
+        if len(self.parameters) == 1:
+            return CodeGen("({arg} == {p})", {"p": self.parameter})
+        else:
+            return CodeGen("({arg} in {ps})", {"ps": self.parameters})
+
+
+@dependent_check
+def HasKeys(value: Mapping, *keys):
+    return all(k in value for k in keys)
+
+
+@dependent_check
+def StartsWith(value: str, prefix):
+    return value.startswith(prefix)
+
+
+@dependent_check
+def EndsWith(value: str, suffix):
+    return value.endswith(suffix)
+
+
+@dependent_check
+def Regexp(value: str, regexp):
+    return bool(re.search(pattern=regexp, string=value))
+
+
+class Dependent:
+    def __class_getitem__(cls, item):
+        bound, dt = item
+        if not isinstance(dt, DependentType):
+            dt = dependent_check(dt)
+        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
+
+    T = TypeVar("T")
+    A = TypeVar("A")
+    Dependent: TypeAlias = Annotated[T, A]
+
+
+__all__ = [
+    "Dependent",
+    "DependentType",
+    "Equals",
+    "HasKeys",
+    "StartsWith",
+    "EndsWith",
+    "dependent_check",
+]

ovld/mro.py

@@ -1,171 +1,182 @@
-# Code lifted from Python's functools module (written for
-# functools.singledispatch)
-# https://github.com/python/cpython/blob/3.8/Lib/functools.py
-
-# We do not cover the functions because they are part of Python's stdlib and we
-# assume they have already been properly tested.
-
-
-def _issubclass(c1, c2):
-    c1 = getattr(c1, "__proxy_for__", c1)
-    c2 = getattr(c2, "__proxy_for__", c2)
-    if hasattr(c1, "__origin__") or hasattr(c2, "__origin__"):
-        o1 = getattr(c1, "__origin__", c1)
-        o2 = getattr(c2, "__origin__", c2)
-        if issubclass(o1, o2):
-            if o2 is c2:  # pragma: no cover
-                return True
-            else:
-                args1 = getattr(c1, "__args__", ())
-                args2 = getattr(c2, "__args__", ())
-                if len(args1) != len(args2):
-                    return False
-                return all(_issubclass(a1, a2) for a1, a2 in zip(args1, args2))
+import typing
+from dataclasses import dataclass
+from enum import Enum
+from graphlib import TopologicalSorter
+
+
+class Order(Enum):
+    LESS = -1
+    MORE = 1
+    SAME = 0
+    NONE = None
+
+    def opposite(self):
+        if self is Order.LESS:
+            return Order.MORE
+        elif self is Order.MORE:
+            return Order.LESS
         else:
-            return False
-    else:
-        return issubclass(c1, c2)
+            return self
 
 
-def _mro(cls):
-    if hasattr(cls, "__mro__"):
-        return set(cls.__mro__)
-    elif hasattr(cls, "__origin__"):
-        return set(cls.__origin__.__mro__)
-    else:  # pragma: no cover
-        return {cls}
+@dataclass
+class TypeRelationship:
+    order: Order
+    matches: bool = None
 
 
-def _subclasses(cls):
-    scf = getattr(cls, "__subclasses__", ())
-    return scf and scf()
+def typeorder(t1, t2):
+    """Order relation between two types.
 
+    Returns a member of the Order enum.
 
-def _c3_merge(sequences):  # pragma: no cover
-    """Merges MROs in *sequences* to a single MRO using the C3 algorithm.
-    Adapted from http://www.python.org/download/releases/2.3/mro/.
+    * typeorder(t1, t2) is Order.LESS   if t2 is more general than t1
+    * typeorder(t1, t2) is Order.SAME   if t1 is equal to t2
+    * typeorder(t1, t2) is Order.MORE   if t1 is more general than t2
+    * typeorder(t1, t2) is Order.NONE   if they cannot be compared
     """
-    result = []
-    while True:
-        sequences = [s for s in sequences if s]  # purge empty sequences
-        if not sequences:
-            return result
-        for s1 in sequences:  # find merge candidates among seq heads
-            candidate = s1[0]
-            for s2 in sequences:
-                if candidate in s2[1:]:
-                    candidate = None
-                    break  # reject the current head, it appears later
-            else:
-                break
-        if candidate is None:
-            raise RuntimeError("Inconsistent hierarchy")
-        result.append(candidate)
-        # remove the chosen candidate
-        for seq in sequences:
-            if seq[0] == candidate:
-                del seq[0]
-
-
-def _c3_mro(cls, abcs=None, abscollect=None):  # pragma: no cover
-    """Computes the method resolution order using extended C3 linearization.
-    If no *abcs* are given, the algorithm works exactly like the built-in C3
-    linearization used for method resolution.
-    If given, *abcs* is a list of abstract base classes that should be inserted
-    into the resulting MRO. Unrelated ABCs are ignored and don't end up in the
-    result. The algorithm inserts ABCs where their functionality is introduced,
-    i.e. issubclass(cls, abc) returns True for the class itself but returns
-    False for all its direct base classes. Implicit ABCs for a given class
-    (either registered or inferred from the presence of a special method like
-    __len__) are inserted directly after the last ABC explicitly listed in the
-    MRO of said class. If two implicit ABCs end up next to each other in the
-    resulting MRO, their ordering depends on the order of types in *abcs*.
-    """
-    bases = getattr(cls, "__bases__", ())
-    if hasattr(cls, "__origin__"):
-        bases = [cls.__origin__, *bases]
-    for i, base in enumerate(reversed(bases)):
-        if hasattr(base, "__abstractmethods__"):
-            boundary = len(bases) - i
-            break  # Bases up to the last explicit ABC are considered first.
+    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
+    ):
+        return result.order
+    elif (
+        hasattr(t2, "__typeorder__")
+        and (result := t2.__typeorder__(t1)) is not NotImplemented
+    ):
+        return result.order.opposite()
+
+    o1 = getattr(t1, "__origin__", None)
+    o2 = getattr(t2, "__origin__", None)
+
+    if o2 is typing.Union:
+        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()
+
+    if o2 and not o1:
+        return typeorder(t2, t1).opposite()
+
+    if o1:
+        if not o2:  # or getattr(t2, "__args__", None) is None:
+            order = typeorder(o1, t2)
+            if order is order.SAME:
+                order = order.LESS
+            return order
+
+        if (order := typeorder(o1, o2)) is not Order.SAME:
+            return order
+
+        args1 = getattr(t1, "__args__", ())
+        args2 = getattr(t2, "__args__", ())
+
+        if args1 and not args2:
+            return Order.LESS
+        if args2 and not args1:
+            return Order.MORE
+        if len(args1) != len(args2):
+            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
+
+    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
+    elif sx:
+        return Order.LESS
+    elif sy:
+        return Order.MORE
     else:
-        boundary = 0
-    abcs = list(abcs) if abcs else []
-    explicit_bases = list(bases[:boundary])
-    abstract_bases = []
-    other_bases = list(bases[boundary:])
-    for base in abcs:
-        if _issubclass(cls, base) and not any(
-            _issubclass(b, base) for b in bases
-        ):
-            # If *cls* is the class that introduces behaviour described by
-            # an ABC *base*, insert said ABC to its MRO.
-            abstract_bases.append(base)
-    for base in abstract_bases:
-        abcs.remove(base)
-    abscollect.update(abstract_bases)
-    explicit_c3_mros = [
-        _c3_mro(base, abcs=abcs, abscollect=abscollect)
-        for base in explicit_bases
-    ]
-    abstract_c3_mros = [
-        _c3_mro(base, abcs=abcs, abscollect=abscollect)
-        for base in abstract_bases
-    ]
-    other_c3_mros = [
-        _c3_mro(base, abcs=abcs, abscollect=abscollect) for base in other_bases
-    ]
-    return _c3_merge(
-        [[cls]]
-        + explicit_c3_mros
-        + abstract_c3_mros
-        + other_c3_mros
-        + [explicit_bases]
-        + [abstract_bases]
-        + [other_bases]
-    )
-
-
-def compose_mro(cls, types, abscollect):  # pragma: no cover
-    """Calculates the method resolution order for a given class *cls*.
-    Includes relevant abstract base classes (with their respective bases) from
-    the *types* iterable. Uses a modified C3 linearization algorithm.
-    """
-    bases = _mro(cls)
+        return Order.NONE
+
+
+def subclasscheck(t1, t2):
+    """Check whether t1 is a "subclass" of t2."""
+    if t1 == t2:
+        return True
 
-    # Remove entries which are already present in the __mro__ or unrelated.
-    def is_related(typ):
-        return typ not in bases and _issubclass(cls, typ)
+    t1 = getattr(t1, "__proxy_for__", t1)
+    t2 = getattr(t2, "__proxy_for__", t2)
 
-    types = [n for n in types if is_related(n)]
+    if (
+        hasattr(t2, "__typeorder__")
+        and (result := t2.__typeorder__(t1)) is not NotImplemented
+    ):
+        return result.matches
 
-    # Remove entries which are strict bases of other entries (they will end up
-    # in the MRO anyway.
-    def is_strict_base(typ):
-        for other in types:
-            if typ != other and typ in _mro(other):
+    o1 = getattr(t1, "__origin__", None)
+    o2 = getattr(t2, "__origin__", None)
+
+    if o2 is typing.Union:
+        return any(subclasscheck(t1, t) for t in t2.__args__)
+    elif o1 is typing.Union:
+        return all(subclasscheck(t, t2) for t in t1.__args__)
+
+    if o1 or o2:
+        o1 = o1 or t1
+        o2 = o2 or t2
+        if issubclass(o1, o2):
+            if o2 is t2:  # pragma: no cover
                 return True
-        return False
-
-    types = [n for n in types if not is_strict_base(n)]
-    # Subclasses of the ABCs in *types* which are also implemented by
-    # *cls* can be used to stabilize ABC ordering.
-    type_set = set(types)
-    mro = []
-    for typ in types:
-        if typ is object:
-            continue
-        found = []
-        for sub in _subclasses(typ):
-            if sub not in bases and _issubclass(cls, sub):
-                found.append([s for s in sub.__mro__ if s in type_set])
-        if not found:
-            mro.append(typ)
-            continue
-        # Favor subclasses with the biggest number of useful bases
-        found.sort(key=len, reverse=True)
-        for sub in found:
-            for subcls in sub:
-                if subcls not in mro:
-                    mro.append(subcls)
-    return _c3_mro(cls, abcs=mro, abscollect=abscollect)
+            else:
+                args1 = getattr(t1, "__args__", ())
+                args2 = getattr(t2, "__args__", ())
+                if len(args1) != len(args2):
+                    return False
+                return all(
+                    subclasscheck(a1, a2) for a1, a2 in zip(args1, args2)
+                )
+        else:
+            return False
+    else:
+        return issubclass(t1, t2)
+
+
+def sort_types(cls, avail):
+    # We filter everything except subclasses and dependent types that *might* cover
+    # the object represented by cls.
+    avail = [t for t in avail if subclasscheck(cls, t)]
+    deps = {t: set() for t in avail}
+    for i, t1 in enumerate(avail):
+        for t2 in avail[i + 1 :]:
+            # NOTE: this is going to scale poorly when there's a hundred Literal in the pool
+            order = typeorder(t1, t2)
+            if order is Order.LESS:
+                deps[t2].add(t1)
+            elif order is Order.MORE:
+                deps[t1].add(t2)
+    sorter = TopologicalSorter(deps)
+    sorter.prepare()
+    while sorter.is_active():
+        nodes = sorter.get_ready()
+        yield nodes
+        for n in nodes:
+            sorter.done(n)