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

ovld/dependent.py

@@ -3,7 +3,6 @@ import re
 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,
@@ -11,57 +10,22 @@ from typing import (
     TypeVar,
 )
 
+from .codegen import Code
 from .types import (
     Intersection,
     Order,
     clsstring,
+    get_args,
     normalize_type,
     subclasscheck,
     typeorder,
 )
 
-_current = count()
-
-
-def generate_checking_code(typ):
-    if hasattr(typ, "codegen"):
-        return typ.codegen()
-    else:
-        return CodeGen("isinstance({arg}, {this})", this=typ)
-
-
-class CodeGen:
-    def __init__(self, template, substitutions={}, **substitutions_kw):
-        self.template = template
-        self.substitutions = {**substitutions, **substitutions_kw}
-
-    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(self.template.format(**renamings), 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)
-
 
 def is_dependent(t):
     if isinstance(t, DependentType):
         return True
-    elif any(is_dependent(subt) for subt in getattr(t, "__args__", ())):
+    elif any(is_dependent(subt) for subt in get_args(t)):
         return True
     return False
 
@@ -89,7 +53,7 @@ class DependentType(type):
         raise NotImplementedError()
 
     def codegen(self):
-        return CodeGen("{this}.check({arg})", this=self)
+        return Code("$this.check($arg)", this=self)
 
     def __type_order__(self, other):
         if isinstance(other, DependentType):
@@ -105,9 +69,7 @@ class DependentType(type):
                     return Order.NONE
             else:  # pragma: no cover
                 return order
-        elif subclasscheck(other, self.bound) or subclasscheck(
-            self.bound, other
-        ):
+        elif subclasscheck(other, self.bound) or subclasscheck(self.bound, other):
             return Order.LESS
         else:
             return Order.NONE
@@ -137,9 +99,7 @@ class DependentType(type):
 
 class ParametrizedDependentType(DependentType):
     def __init__(self, *parameters, bound=None):
-        super().__init__(
-            self.default_bound(*parameters) if bound is None else bound
-        )
+        super().__init__(self.default_bound(*parameters) if bound is None else bound)
         self.__args__ = self.parameters = parameters
         self.__origin__ = None
         self.__post_init__()
@@ -191,12 +151,10 @@ class FuncDependentType(ParametrizedDependentType):
         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)
+            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)
+            p2 is Any and p1 is not Any for p1, p2 in zip(self.parameters, other.parameters)
         )
         return p2g and not p1g
 
@@ -255,16 +213,16 @@ class Equals(ParametrizedDependentType):
 
     @classmethod
     def keygen(cls):
-        return "{arg}"
+        return Code("$arg")
 
     def get_keys(self):
         return [self.parameter]
 
     def codegen(self):
         if len(self.parameters) == 1:
-            return CodeGen("({arg} == {p})", p=self.parameter)
+            return Code("($arg == $p)", p=self.parameter)
         else:
-            return CodeGen("({arg} in {ps})", ps=self.parameters)
+            return Code("($arg in $ps)", ps=self.parameters)
 
 
 class ProductType(ParametrizedDependentType):
@@ -281,19 +239,18 @@ class ProductType(ParametrizedDependentType):
         )
 
     def codegen(self):
-        checks = ["len({arg}) == {n}"]
+        checks = ["len($arg) == $n"]
         params = {"n": len(self.parameters)}
         for i, p in enumerate(self.parameters):
-            checks.append(f"isinstance({{arg}}[{i}], {{p{i}}})")
+            checks.append(f"isinstance($arg[{i}], $p{i})")
             params[f"p{i}"] = p
-        return CodeGen(" and ".join(checks), params)
+        return Code(" 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)
+                    typeorder(a, b) for a, b in zip(self.parameters, other.parameters)
                 )
             else:
                 return Order.NONE
@@ -337,8 +294,14 @@ def Callable(fn: _Callable, argt, rett):
 
 
 @dependent_check
-def HasKey(value: Mapping, *keys):
-    return all(k in value for k in keys)
+class HasKey:
+    def check(self, value: Mapping):
+        return all(k in value for k in self.parameters)
+
+    def codegen(self):
+        return Code(
+            "($[ and ]checks)", checks=[Code("($k in $arg)", k=k) for k in self.parameters]
+        )
 
 
 @dependent_check
@@ -360,7 +323,7 @@ class Regexp:
         return bool(self.rx.search(value))
 
     def codegen(self):
-        return CodeGen("bool({rx}.search({arg}))", rx=self.rx)
+        return Code("bool($rx.search($arg))", rx=self.rx)
 
 
 class Dependent:
@@ -377,14 +340,3 @@ if TYPE_CHECKING:  # pragma: no cover
     T = TypeVar("T")
     A = TypeVar("A")
     Dependent: TypeAlias = Annotated[T, A]
-
-
-__all__ = [
-    "Dependent",
-    "DependentType",
-    "Equals",
-    "HasKey",
-    "StartsWith",
-    "EndsWith",
-    "dependent_check",
-]

ovld/medley.py

@@ -0,0 +1,408 @@
+import functools
+import inspect
+from copy import copy
+from dataclasses import MISSING, dataclass, fields, make_dataclass, replace
+from typing import Annotated, TypeVar, get_origin
+
+from .core import Ovld, to_ovld
+from .types import eval_annotation
+from .utils import Named
+
+ABSENT = Named("ABSENT")
+CODEGEN = Named("CODEGEN")
+
+
+class Combiner:
+    def __init__(self, field=None):
+        self.field = field
+
+    def __set_name__(self, obj, field):
+        self.field = field
+
+    def get(self, cls):  # pragma: no cover
+        raise NotImplementedError()
+
+    def copy(self):
+        return type(self)(self.field)
+
+    def include(self, other):
+        if type(self) is not type(other):
+            raise TypeError("Cannot merge different combiner classes.")
+        self.include_sametype(other)
+
+    def include_sametype(self, other):  # pragma: no cover
+        pass
+
+    def juxtapose(self, impl):  # pragma: no cover
+        raise NotImplementedError()
+
+
+class KeepLast(Combiner):
+    def __init__(self, field=None):
+        super().__init__(field)
+        self.impl = ABSENT
+
+    def get(self, cls):
+        return self.impl
+
+    def include_sametype(self, other):
+        self.impl = other.impl
+
+    def juxtapose(self, impl):
+        self.impl = impl
+
+
+class ImplList(Combiner):
+    def __init__(self, field=None, impls=None):
+        super().__init__(field)
+        self.impls = impls or []
+
+    def copy(self):
+        return type(self)(self.field, self.impls)
+
+    def get(self, cls):
+        if not self.impls:
+            return ABSENT
+        rval = self.wrap()
+        return functools.wraps(self.impls[0])(rval)
+
+    def wrap(self):  # pragma: no cover
+        raise NotImplementedError()
+
+    def include_sametype(self, other):
+        self.impls += other.impls
+
+    def juxtapose(self, impl):
+        self.impls.append(impl)
+
+
+class RunAll(ImplList):
+    def wrap(_self):
+        def run_all(self, *args, **kwargs):
+            for impl in _self.impls:
+                impl(self, *args, **kwargs)
+
+        return run_all
+
+
+class ReduceAll(ImplList):
+    def wrap(_self):
+        def reduce_all(self, x, *args, **kwargs):
+            result = _self.impls[0](self, x, *args, **kwargs)
+            for impl in _self.impls[1:]:
+                result = impl(self, result, *args, **kwargs)
+            return result
+
+        return reduce_all
+
+
+class ChainAll(ImplList):
+    def wrap(_self):
+        def chain_all(self, *args, **kwargs):
+            self = _self.impls[0](self, *args, **kwargs)
+            for impl in _self.impls[1:]:
+                self = impl(self, *args, **kwargs)
+            return self
+
+        return chain_all
+
+
+class BuildOvld(Combiner):
+    def __init__(self, field=None, ovld=None):
+        super().__init__(field)
+        self.ovld = ovld or Ovld(linkback=True)
+        self.pending = []
+        if field is not None:
+            self.__set_name__(None, field)
+
+    def __set_name__(self, obj, field):
+        self.ovld.rename(field)
+
+    def get(self, cls):
+        self.ovld.specialization_self = cls
+        for f, arg in self.pending:
+            f(arg)
+        self.pending.clear()
+        if not self.ovld.defns:
+            return ABSENT
+        self.ovld.compile()
+        return self.ovld.dispatch
+
+    def copy(self):
+        return type(self)(self.field, self.ovld.copy(linkback=True))
+
+    def include_sametype(self, other):
+        self.ovld.add_mixins(other.ovld)
+
+    def juxtapose(self, impl):
+        if ov := to_ovld(impl, force=False):
+            self.pending.append((self.ovld.add_mixins, ov))
+        elif inspect.isfunction(impl):
+            self.pending.append((self.ovld.register, impl))
+        else:  # pragma: no cover
+            raise TypeError("Expected a function or ovld.")
+
+
+class medley_cls_dict(dict):
+    def __init__(self, bases):
+        super().__init__()
+        self._combiners = {}
+        self.set_direct("_ovld_combiners", self._combiners)
+        self._basic = set()
+        for base in bases:
+            for attr, combiner in getattr(base, "_ovld_combiners", {}).items():
+                if attr in self._combiners:
+                    self._combiners[attr].include(combiner)
+                else:
+                    self._combiners[attr] = combiner.copy()
+
+    def set_direct(self, attr, value):
+        super().__setitem__(attr, value)
+
+    def __setitem__(self, attr, value):
+        if attr == "__annotations__":
+            self.set_direct(attr, value)
+            return
+
+        if attr == "__init__":
+            raise Exception("Do not define __init__ in a Medley, use __post_init__.")
+
+        if isinstance(value, Combiner):
+            value.__set_name__(None, attr)
+            self._combiners[attr] = value
+            return
+
+        combiner = self._combiners.get(attr, None)
+        if combiner is None:
+            if inspect.isfunction(value) or isinstance(value, Ovld):
+                combiner = BuildOvld(attr)
+            else:
+                combiner = KeepLast(attr)
+            self._combiners[attr] = combiner
+
+        combiner.juxtapose(value)
+
+    def __missing__(self, attr):
+        if attr in self._combiners:
+            if (value := self._combiners[attr].get(None)) is not ABSENT:
+                return value
+        raise KeyError(attr)
+
+
+def codegen_key(*instances):
+    rval = {}
+    for instance in instances:
+        keyd = {name: getattr(instance, name) for name in type(instance)._ovld_codegen_fields}
+        rval.update(keyd)
+    return rval
+
+
+def specialize(cls, key):
+    ns = medley_cls_dict((cls,))
+    new_t = MedleyMC(cls.__name__, (cls,), ns)
+    new_t._ovld_specialization_parent = cls
+    for k, v in key.items():
+        setattr(new_t, k, v)
+    cls._ovld_codegen_fields = list(key.keys())
+    return new_t
+
+
+class MedleyMC(type):
+    def __subclasscheck__(cls, subclass):
+        if getattr(cls, "_ovld_medleys", None):
+            return all(issubclass(subclass, m) for m in cls._ovld_medleys)
+        return super().__subclasscheck__(subclass)
+
+    @classmethod
+    def __prepare__(mcls, name, bases):
+        return medley_cls_dict(bases)
+
+    def __new__(mcls, name, bases, namespace):
+        result = super().__new__(mcls, name, bases, namespace)
+        for attr, combiner in result._ovld_combiners.items():
+            if (value := combiner.get(result)) is not ABSENT:
+                setattr(result, attr, value)
+        dc = dataclass(result)
+        dc._ovld_specialization_parent = None
+        dc._ovld_specializations = {}
+        dc._ovld_codegen_fields = [
+            field.name
+            for field in fields(dc)
+            if (
+                (t := eval_annotation(field.type, dc, {}, catch=True))
+                and get_origin(t) is Annotated
+                and CODEGEN in t.__metadata__
+            )
+        ]
+        return dc
+
+    def extend(cls, *others):
+        if not others:
+            return cls
+        melded = meld_classes((cls, *others), require_defaults=True)
+        for other in others:
+            for k, v in vars(other).items():
+                if k in ["__module__", "__firstlineno__"]:
+                    continue
+                elif comb := cls._ovld_combiners.get(k):
+                    comb.juxtapose(v)
+                    setattr(cls, k, comb.get(cls))
+                elif not k.startswith("_ovld_") and not k.startswith("__"):
+                    setattr(cls, k, v)
+        cls.__init__ = melded.__init__
+        for subcls in cls.__subclasses__():
+            subothers = [o for o in others if not issubclass(subcls, o)]
+            subcls.extend(*subothers)
+        return cls
+
+    def __add__(cls, other):
+        return meld_classes((cls, other))
+
+    def __iadd__(cls, other):
+        return cls.extend(other)
+
+    def __sub__(cls, other):
+        return unmeld_classes(cls, other)
+
+    def __call__(cls, *args, **kwargs):
+        made = super().__call__(*args, **kwargs)
+        if cls._ovld_codegen_fields and (keyd := codegen_key(made)):
+            cls = cls._ovld_specialization_parent or cls
+            key = tuple(sorted(keyd.items()))
+            if key in cls._ovld_specializations:
+                new_t = cls._ovld_specializations[key]
+            else:
+                new_t = specialize(cls, keyd)
+                cls._ovld_specializations[key] = new_t
+            obj = object.__new__(new_t)
+            obj.__dict__.update(made.__dict__)
+            return obj
+        else:
+            return made
+
+
+def use_combiner(combiner):
+    def deco(fn):
+        cmb = combiner(fn.__name__)
+        cmb.juxtapose(fn)
+        return cmb
+
+    return deco
+
+
+class Medley(metaclass=MedleyMC):
+    __post_init__ = RunAll()
+    __add__ = KeepLast()
+    __sub__ = KeepLast()
+
+    def __add__(self, other):
+        if isinstance(self, type(other)) and not type(self)._ovld_codegen_fields:
+            return replace(self, **vars(other))
+        else:
+            return meld([self, other])
+
+    def __sub__(self, other):
+        return unmeld(self, other)
+
+
+def unmeld_classes(main: type, exclude: type):
+    classes = tuple(c for c in main.__bases__ if c is not exclude)
+    return meld_classes(classes)
+
+
+_meld_classes_cache = {}
+
+
+def meld_classes(classes, require_defaults=False):
+    medleys = {}
+    for i, cls in enumerate(classes):
+        if require_defaults and i == 0:
+            medleys[cls] = True
+        else:
+            medleys.update({x: True for x in getattr(cls, "_ovld_medleys", [cls])})
+    for cls in classes:
+        if not hasattr(cls, "_ovld_medleys"):
+            for base in cls.mro():
+                if base is not cls and base in medleys:
+                    del medleys[base]
+    medleys = tuple(medleys)
+    if len(medleys) == 1:
+        return medleys[0]
+
+    cache_key = (medleys, require_defaults)
+    if cache_key in _meld_classes_cache:
+        return _meld_classes_cache[cache_key]
+
+    def remap_field(dc_field, require_default):
+        if require_default:
+            if dc_field.default is MISSING:
+                # NOTE: we do not accept default_factory, because we need the default value to be set
+                # in the class so that existing instances of classes[0] can see it.
+                raise TypeError(
+                    f"Dataclass field '{dc_field.name}' must have a default value (not a default_factory) in order to be melded in."
+                )
+        dc_field = copy(dc_field)
+        dc_field.kw_only = True
+        return dc_field
+
+    cg_fields = set()
+    dc_fields = []
+
+    for base in medleys:
+        rqdef = require_defaults and base is not medleys[0]
+        cg_fields.update(base._ovld_codegen_fields)
+        dc_fields.extend(
+            (f.name, f.type, remap_field(f, rqdef)) for f in base.__dataclass_fields__.values()
+        )
+
+    merged = medley_cls_dict(medleys)
+    merged.set_direct("_ovld_codegen_fields", tuple(cg_fields))
+    merged.set_direct("_ovld_medleys", tuple(medleys))
+
+    result = make_dataclass(
+        cls_name="+".join(sorted(c.__name__ for c in medleys)),
+        bases=tuple(medleys),
+        fields=dc_fields,
+        kw_only=True,
+        namespace=merged,
+    )
+
+    _meld_classes_cache[cache_key] = result
+    return result
+
+
+@functools.cache
+def meld_classes_with_key(classes, key):
+    key = dict(key)
+    typ = meld_classes(classes)
+    if not key:
+        return typ
+    else:
+        return specialize(typ, key)
+
+
+def meld(objects):
+    key = codegen_key(*objects)
+    classes = tuple(type(o) for o in objects)
+    cls = meld_classes_with_key(classes, tuple(key.items()))
+    obj = object.__new__(cls)
+    for o in objects:
+        for k, v in vars(o).items():
+            setattr(obj, k, v)
+    return obj
+
+
+def unmeld(obj: object, exclude: type):
+    if type(obj)._ovld_codegen_fields:  # pragma: no cover
+        raise TypeError("Cannot unmeld an object with codegen fields")
+    cls = unmeld_classes(type(obj), exclude)
+    values = {}
+    excluded = exclude.__dataclass_fields__
+    for f in cls.__dataclass_fields__.values():
+        if f.name not in excluded:
+            values[f.name] = getattr(obj, f.name)
+    return cls(**values)
+
+
+T = TypeVar("T")
+CodegenParameter = Annotated[T, CODEGEN]

ovld/mro.py

@@ -3,6 +3,8 @@ from enum import Enum
 from graphlib import TopologicalSorter
 from typing import get_args, get_origin
 
+from .utils import UnionTypes
+
 
 class Order(Enum):
     LESS = -1
@@ -121,6 +123,9 @@ def subclasscheck(t1, t2):
     ):
         return result
 
+    if t2 in UnionTypes:
+        return isinstance(t1, t2)
+
     o1 = get_origin(t1)
     o2 = get_origin(t2)
 
@@ -140,9 +145,7 @@ def subclasscheck(t1, t2):
                 args2 = get_args(t2)
                 if len(args1) != len(args2):
                     return False
-                return all(
-                    subclasscheck(a1, a2) for a1, a2 in zip(args1, args2)
-                )
+                return all(subclasscheck(a1, a2) for a1, a2 in zip(args1, args2))
         else:
             return False
     else: