ovld 0.4.6__py3-none-any.whl → 0.5.1__py3-none-any.whl

ovld/core.py

@@ -4,11 +4,9 @@ import inspect
 import itertools
 import sys
 import textwrap
-import typing
-from collections import OrderedDict, defaultdict
-from dataclasses import dataclass, field, replace
-from functools import cached_property, partial
-from types import FunctionType, GenericAlias
+from dataclasses import replace
+from functools import partial
+from types import FunctionType
 
 from .recode import (
     Conformer,
@@ -16,97 +14,20 @@ from .recode import (
     generate_dispatch,
     rename_code,
 )
+from .signatures import ArgumentAnalyzer, LazySignature, Signature
 from .typemap import MultiTypeMap
-from .types import clsstring, normalize_type
-from .utils import MISSING, UsageError, keyword_decorator, subtler_type
+from .utils import (
+    MISSING,
+    ResolutionError,
+    UsageError,
+    keyword_decorator,
+    sigstring,
+    subtler_type,
+)
 
 _current_id = itertools.count()
 
 
-@keyword_decorator
-def _setattrs(fn, **kwargs):
-    for k, v in kwargs.items():
-        setattr(fn, k, v)
-    return fn
-
-
-class LazySignature(inspect.Signature):
-    def __init__(self, ovld):
-        super().__init__([])
-        self.ovld = ovld
-
-    def replace(
-        self, *, parameters=inspect._void, return_annotation=inspect._void
-    ):  # pragma: no cover
-        if parameters is inspect._void:
-            parameters = self.parameters.values()
-
-        if return_annotation is inspect._void:
-            return_annotation = self._return_annotation
-
-        return inspect.Signature(
-            parameters, return_annotation=return_annotation
-        )
-
-    @property
-    def parameters(self):
-        anal = self.ovld.analyze_arguments()
-        parameters = []
-        if anal.is_method:
-            parameters.append(
-                inspect.Parameter(
-                    name="self",
-                    kind=inspect._POSITIONAL_ONLY,
-                )
-            )
-        parameters += [
-            inspect.Parameter(
-                name=p,
-                kind=inspect._POSITIONAL_ONLY,
-            )
-            for p in anal.strict_positional_required
-        ]
-        parameters += [
-            inspect.Parameter(
-                name=p,
-                kind=inspect._POSITIONAL_ONLY,
-                default=MISSING,
-            )
-            for p in anal.strict_positional_optional
-        ]
-        parameters += [
-            inspect.Parameter(
-                name=p,
-                kind=inspect._POSITIONAL_OR_KEYWORD,
-            )
-            for p in anal.positional_required
-        ]
-        parameters += [
-            inspect.Parameter(
-                name=p,
-                kind=inspect._POSITIONAL_OR_KEYWORD,
-                default=MISSING,
-            )
-            for p in anal.positional_optional
-        ]
-        parameters += [
-            inspect.Parameter(
-                name=p,
-                kind=inspect._KEYWORD_ONLY,
-            )
-            for p in anal.keyword_required
-        ]
-        parameters += [
-            inspect.Parameter(
-                name=p,
-                kind=inspect._KEYWORD_ONLY,
-                default=MISSING,
-            )
-            for p in anal.keyword_optional
-        ]
-        return OrderedDict({p.name: p for p in parameters})
-
-
 def bootstrap_dispatch(ov, name):
     def first_entry(*args, **kwargs):
         ov.compile()
@@ -122,6 +43,7 @@ def bootstrap_dispatch(ov, name):
     dispatch.__signature__ = LazySignature(ov)
     dispatch.__ovld__ = ov
     dispatch.register = ov.register
+    dispatch.resolve_for_values = ov.resolve_for_values
     dispatch.resolve = ov.resolve
     dispatch.copy = ov.copy
     dispatch.variant = ov.variant
@@ -130,214 +52,10 @@ def bootstrap_dispatch(ov, name):
     dispatch.add_mixins = ov.add_mixins
     dispatch.unregister = ov.unregister
     dispatch.next = ov.next
+    dispatch.first_entry = first_entry
     return dispatch
 
 
-@dataclass(frozen=True)
-class Arginfo:
-    position: typing.Optional[int]
-    name: typing.Optional[str]
-    required: bool
-    ann: type
-
-    @cached_property
-    def is_complex(self):
-        return isinstance(self.ann, GenericAlias)
-
-    @cached_property
-    def canonical(self):
-        return self.name if self.position is None else self.position
-
-
-@dataclass(frozen=True)
-class Signature:
-    types: tuple
-    return_type: type
-    req_pos: int
-    max_pos: int
-    req_names: frozenset
-    vararg: bool
-    priority: float
-    tiebreak: int = 0
-    is_method: bool = False
-    arginfo: list[Arginfo] = field(
-        default_factory=list, hash=False, compare=False
-    )
-
-    @classmethod
-    def extract(cls, fn):
-        typelist = []
-        sig = inspect.signature(fn)
-        max_pos = 0
-        req_pos = 0
-        req_names = set()
-        is_method = False
-
-        arginfo = []
-        for i, (name, param) in enumerate(sig.parameters.items()):
-            if name == "self":
-                assert i == 0
-                is_method = True
-                continue
-            pos = nm = None
-            ann = normalize_type(param.annotation, fn)
-            if param.kind is inspect._POSITIONAL_ONLY:
-                pos = i - is_method
-                typelist.append(ann)
-                req_pos += param.default is inspect._empty
-                max_pos += 1
-            elif param.kind is inspect._POSITIONAL_OR_KEYWORD:
-                pos = i - is_method
-                nm = param.name
-                typelist.append(ann)
-                req_pos += param.default is inspect._empty
-                max_pos += 1
-            elif param.kind is inspect._KEYWORD_ONLY:
-                nm = param.name
-                typelist.append((param.name, ann))
-                if param.default is inspect._empty:
-                    req_names.add(param.name)
-            elif param.kind is inspect._VAR_POSITIONAL:
-                raise TypeError("ovld does not support *args")
-            elif param.kind is inspect._VAR_KEYWORD:
-                raise TypeError("ovld does not support **kwargs")
-            arginfo.append(
-                Arginfo(
-                    position=pos,
-                    name=nm,
-                    required=param.default is inspect._empty,
-                    ann=normalize_type(param.annotation, fn),
-                )
-            )
-
-        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),
-            vararg=False,
-            is_method=is_method,
-            priority=None,
-            arginfo=arginfo,
-        )
-
-
-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))
-
-
-class ArgumentAnalyzer:
-    def __init__(self):
-        self.name_to_positions = defaultdict(set)
-        self.position_to_names = defaultdict(set)
-        self.counts = defaultdict(lambda: [0, 0])
-        self.complex_transforms = set()
-        self.total = 0
-        self.is_method = None
-        self.done = False
-
-    def add(self, fn):
-        self.done = False
-        sig = Signature.extract(fn)
-        self.complex_transforms.update(
-            arg.canonical for arg in sig.arginfo if arg.is_complex
-        )
-        for arg in sig.arginfo:
-            if arg.position is not None:
-                self.position_to_names[arg.position].add(arg.name)
-            if arg.name is not None:
-                self.name_to_positions[arg.name].add(arg.canonical)
-
-            cnt = self.counts[arg.canonical]
-            cnt[0] += arg.required
-            cnt[1] += 1
-
-        self.total += 1
-
-        if self.is_method is None:
-            self.is_method = sig.is_method
-        elif self.is_method != sig.is_method:  # pragma: no cover
-            raise TypeError(
-                "Some, but not all registered methods define `self`. It should be all or none."
-            )
-
-    def compile(self):
-        if self.done:
-            return
-        for name, pos in self.name_to_positions.items():
-            if len(pos) != 1:
-                if all(isinstance(p, int) for p in pos):
-                    raise TypeError(
-                        f"Argument '{name}' is declared in different positions by different methods. The same argument name should always be in the same position unless it is strictly positional."
-                    )
-                else:
-                    raise TypeError(
-                        f"Argument '{name}' is declared in a positional and keyword setting by different methods. It should be either."
-                    )
-
-        p_to_n = [
-            list(names) for _, names in sorted(self.position_to_names.items())
-        ]
-
-        positional = list(
-            itertools.takewhile(
-                lambda names: len(names) == 1 and isinstance(names[0], str),
-                reversed(p_to_n),
-            )
-        )
-        positional.reverse()
-        strict_positional = p_to_n[: len(p_to_n) - len(positional)]
-
-        assert strict_positional + positional == p_to_n
-
-        self.strict_positional_required = [
-            f"ARG{pos + 1}"
-            for pos, _ in enumerate(strict_positional)
-            if self.counts[pos][0] == self.total
-        ]
-        self.strict_positional_optional = [
-            f"ARG{pos + 1}"
-            for pos, _ in enumerate(strict_positional)
-            if self.counts[pos][0] != self.total
-        ]
-
-        self.positional_required = [
-            names[0]
-            for pos, names in enumerate(positional)
-            if self.counts[pos + len(strict_positional)][0] == self.total
-        ]
-        self.positional_optional = [
-            names[0]
-            for pos, names in enumerate(positional)
-            if self.counts[pos + len(strict_positional)][0] != self.total
-        ]
-
-        keywords = [
-            name
-            for _, (name,) in self.name_to_positions.items()
-            if not isinstance(name, int)
-        ]
-        self.keyword_required = [
-            name for name in keywords if self.counts[name][0] == self.total
-        ]
-        self.keyword_optional = [
-            name for name in keywords if self.counts[name][0] != self.total
-        ]
-        self.done = True
-
-    def lookup_for(self, key):
-        return subtler_type if key in self.complex_transforms else type
-
-
 class Ovld:
     """Overloaded function.
 
@@ -367,6 +85,7 @@ class Ovld:
     ):
         """Initialize an Ovld."""
         self.id = next(_current_id)
+        self.specialization_self = MISSING
         self._compiled = False
         self.linkback = linkback
         self.children = []
@@ -378,6 +97,7 @@ class Ovld:
         self._locked = False
         self.mixins = []
         self.argument_analysis = ArgumentAnalyzer()
+        self.dispatch = bootstrap_dispatch(self, name=self.shortname)
         self.add_mixins(*mixins)
 
     @property
@@ -396,23 +116,26 @@ class Ovld:
         return self.argument_analysis
 
     def mkdoc(self):
-        docs = [fn.__doc__ for fn in self.defns.values() if fn.__doc__]
-        if len(docs) == 1:
-            maindoc = docs[0]
-        else:
-            maindoc = f"Ovld with {len(self.defns)} methods."
-
-        doc = f"{maindoc}\n\n"
-        for fn in self.defns.values():
-            fndef = inspect.signature(fn)
-            fdoc = fn.__doc__
-            if not fdoc or fdoc == maindoc:
-                doc += f"{self.__name__}{fndef}\n\n"
+        try:
+            docs = [fn.__doc__ for fn in self.defns.values() if fn.__doc__]
+            if len(docs) == 1:
+                maindoc = docs[0]
             else:
-                if not fdoc.strip(" ").endswith("\n"):
-                    fdoc += "\n"
-                fdoc = textwrap.indent(fdoc, " " * 4)
-                doc += f"{self.__name__}{fndef}\n{fdoc}\n"
+                maindoc = f"Ovld with {len(self.defns)} methods."
+
+            doc = f"{maindoc}\n\n"
+            for fn in self.defns.values():
+                fndef = inspect.signature(fn)
+                fdoc = fn.__doc__
+                if not fdoc or fdoc == maindoc:
+                    doc += f"{self.__name__}{fndef}\n\n"
+                else:
+                    if not fdoc.strip(" ").endswith("\n"):
+                        fdoc += "\n"
+                    fdoc = textwrap.indent(fdoc, " " * 4)
+                    doc += f"{self.__name__}{fndef}\n{fdoc}\n"
+        except Exception as exc:  # pragma: no cover
+            doc = f"An exception occurred when calculating the docstring: {exc}"
         return doc
 
     @property
@@ -442,14 +165,12 @@ class Ovld:
     def _key_error(self, key, possibilities=None):
         typenames = sigstring(key)
         if not possibilities:
-            return TypeError(
-                f"No method in {self} for argument types [{typenames}]"
-            )
+            return ResolutionError(f"No method in {self} for argument types [{typenames}]")
         else:
             hlp = ""
             for c in possibilities:
                 hlp += f"* {c.handler.__name__}  (priority: {c.priority}, specificity: {list(c.specificity)})\n"
-            return TypeError(
+            return ResolutionError(
                 f"Ambiguous resolution in {self} for"
                 f" argument types [{typenames}]\n"
                 f"Candidates are:\n{hlp}"
@@ -458,10 +179,14 @@ class Ovld:
 
     def rename(self, name, shortname=None):
         """Rename this Ovld."""
-        self.name = name
-        self.shortname = shortname or name
-        self.__name__ = shortname
-        self.dispatch = bootstrap_dispatch(self, name=self.shortname)
+        if name != self.name:
+            self.name = name
+            self.shortname = shortname or name
+            self.__name__ = self.shortname
+            self.dispatch = bootstrap_dispatch(self, name=self.shortname)
+
+    def __set_name__(self, inst, name):
+        self.rename(name)
 
     def _set_attrs_from(self, fn):
         """Inherit relevant attributes from the function."""
@@ -492,12 +217,10 @@ class Ovld:
             self.name = self.__name__ = f"ovld{self.id}"
 
         name = self.__name__
-        self.map = MultiTypeMap(name=name, key_error=self._key_error)
+        self.map = MultiTypeMap(name=name, key_error=self._key_error, ovld=self)
 
         self.analyze_arguments()
         dispatch = generate_dispatch(self, self.argument_analysis)
-        if not hasattr(self, "dispatch"):
-            self.dispatch = bootstrap_dispatch(self, name=self.shortname)
         self.dispatch.__code__ = rename_code(dispatch.__code__, self.shortname)
         self.dispatch.__kwdefaults__ = dispatch.__kwdefaults__
         self.dispatch.__annotations__ = dispatch.__annotations__
@@ -511,16 +234,22 @@ class Ovld:
 
         self._compiled = True
 
-    def resolve(self, *args):
+    def resolve_for_values(self, *args):
         """Find the correct method to call for the given arguments."""
         self.ensure_compiled()
         return self.map[tuple(map(subtler_type, args))]
 
+    def resolve(self, *args, after=None):
+        """Find the correct method to call for the given argument types."""
+        self.ensure_compiled()
+        if after:
+            return self.map[(getattr(after, "__code__", after), *args)]
+        else:
+            return self.map[args]
+
     def register_signature(self, sig, orig_fn):
         """Register a function for the given signature."""
-        fn = adapt_function(
-            orig_fn, self, f"{self.__name__}[{sigstring(sig.types)}]"
-        )
+        fn = adapt_function(orig_fn, self, f"{self.__name__}[{sigstring(sig.types)}]")
         # We just need to keep the Conformer pointer alive for jurigged
         # to find it, if jurigged is used with ovld
         fn._conformer = Conformer(self, orig_fn, fn)
@@ -531,6 +260,7 @@ class Ovld:
         """Register a function."""
         if fn is None:
             return partial(self._register, priority=priority)
+        priority = getattr(fn, "priority", priority)
         return self._register(fn, priority)
 
     def _register(self, fn, priority):
@@ -542,9 +272,7 @@ class Ovld:
 
         sig = replace(Signature.extract(fn), priority=priority)
         if not self.allow_replacement and sig in self._defns:
-            raise TypeError(
-                f"There is already a method for {sigstring(sig.types)}"
-            )
+            raise TypeError(f"There is already a method for {sigstring(sig.types)}")
 
         def _set(sig, fn):
             if sig in self._defns:
@@ -565,13 +293,16 @@ class Ovld:
         self._update()
 
     def _update(self):
-        if self._compiled:
-            self.compile()
+        self.reset()
         for child in self.children:
             child._update()
         if hasattr(self, "dispatch"):
             self.dispatch.__doc__ = self.mkdoc()
 
+    def reset(self):
+        self._compiled = False
+        self.dispatch.__code__ = self.dispatch.first_entry.__code__
+
     def copy(self, mixins=[], linkback=False):
         """Create a copy of this Ovld.
 
@@ -594,21 +325,15 @@ class Ovld:
             return ov
 
     def __get__(self, obj, cls):
-        if not self._compiled:
-            self.compile()
         return self.dispatch.__get__(obj, cls)
 
-    @_setattrs(rename="dispatch")
     def __call__(self, *args, **kwargs):  # pragma: no cover
         """Call the overloaded function.
 
         This should be replaced by an auto-generated function.
         """
-        if not self._compiled:
-            self.compile()
         return self.dispatch(*args, **kwargs)
 
-    @_setattrs(rename="next")
     def next(self, *args):
         """Call the next matching method after the caller, in terms of priority or specificity."""
         fr = sys._getframe(1)
@@ -630,16 +355,14 @@ class Ovld:
 
 def is_ovld(x):
     """Return whether the argument is an ovld function/method."""
-    return isinstance(x, Ovld) or isinstance(
-        getattr(x, "__ovld__", False), Ovld
-    )
+    return isinstance(x, Ovld) or isinstance(getattr(x, "__ovld__", False), Ovld)
 
 
-def to_ovld(x):
-    """Return whether the argument is an ovld function/method."""
+def to_ovld(x, force=True):
+    """Return the argument as an Ovld."""
     x = getattr(x, "__ovld__", x)
     if inspect.isfunction(x):
-        return ovld(x, fresh=True)
+        return (ovld(x, fresh=True).__ovld__) if force else None
     else:
         return x if isinstance(x, Ovld) else None
 
@@ -694,9 +417,7 @@ class ovld_cls_dict(dict):
                 prev.register(value)
                 value = prev
 
-        super().__setitem__(
-            attr, value.dispatch if isinstance(value, Ovld) else value
-        )
+        super().__setitem__(attr, value.dispatch if isinstance(value, Ovld) else value)
 
 
 class OvldMC(type):
@@ -713,7 +434,7 @@ class OvldMC(type):
         return type(cls)(name, bases, cls.__prepare__(name, bases))
 
     @classmethod
-    def __prepare__(cls, name, bases):
+    def __prepare__(metacls, name, bases):
         d = ovld_cls_dict(bases)
 
         names = set()
@@ -723,9 +444,7 @@ class OvldMC(type):
         for name in names:
             values = [getattr(base, name, None) for base in bases]
             ovlds = [v for v in values if is_ovld(v)]
-            mixins = [
-                v for v in ovlds[1:] if getattr(v, "_extend_super", False)
-            ]
+            mixins = [v for v in ovlds[1:] if getattr(v, "_extend_super", False)]
             if mixins:
                 o = ovlds[0].copy(mixins=mixins)
                 others = [v for v in values if v is not None and not is_ovld(v)]
@@ -736,6 +455,12 @@ class OvldMC(type):
 
         return d
 
+    def __init__(cls, name, bases, d):
+        for val in d.values():
+            if o := to_ovld(val, force=False):
+                o.specialization_self = cls
+        super().__init__(name, bases, d)
+
 
 class OvldBase(metaclass=OvldMC):
     """Base class that allows overloading of methods."""
@@ -796,13 +521,3 @@ def ovld(fn, priority=0, fresh=False, **kwargs):
         dispatch = _find_overload(fn, **kwargs)
     dispatch.register(fn, priority=priority)
     return dispatch.dispatch
-
-
-__all__ = [
-    "Ovld",
-    "OvldBase",
-    "OvldMC",
-    "extend_super",
-    "is_ovld",
-    "ovld",
-]