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

ovld/types.py

@@ -2,11 +2,12 @@ import inspect
 import sys
 import typing
 from dataclasses import dataclass
+from functools import partial
 from typing import Protocol, runtime_checkable
 
-from ovld.utils import UsageError
-
 from .mro import Order, TypeRelationship, subclasscheck, typeorder
+from .typemap import TypeMap
+from .utils import UsageError, clsstring
 
 try:
     from types import UnionType
@@ -14,66 +15,152 @@ except ImportError:  # pragma: no cover
     UnionType = None
 
 
-def normalize_type(t, fn):
-    from .dependent import DependentType, Equals
-
-    if isinstance(t, str):
-        t = eval(t, getattr(fn, "__globals__", {}))
-
-    if t is type:
-        t = type[object]
-    elif t is typing.Any:
-        t = object
-    elif t is inspect._empty:
-        t = object
-    elif isinstance(t, typing._AnnotatedAlias):
-        t = t.__origin__
-
-    origin = getattr(t, "__origin__", None)
-    if UnionType and isinstance(t, UnionType):
-        return normalize_type(t.__args__, fn)
-    elif origin is type:
-        return t
-    elif origin is typing.Union:
-        return normalize_type(t.__args__, fn)
-    elif origin is typing.Literal:
-        return Equals(*t.__args__)
-    elif origin and not getattr(t, "__args__", None):
-        return t
-    elif origin is not None:
-        raise TypeError(
-            f"ovld does not accept generic types except type, Union, Optional, Literal, but not: {t}"
-        )
-    elif isinstance(t, tuple):
-        return typing.Union[tuple(normalize_type(t2, fn) for t2 in t)]
-    elif isinstance(t, DependentType) and not t.bound:
-        raise UsageError(
-            f"Dependent type {t} has not been given a type bound. Please use Dependent[<bound>, {t}] instead."
-        )
-    else:
-        return t
+class TypeNormalizer:
+    def __init__(self, generic_handlers=None):
+        self.generic_handlers = generic_handlers or TypeMap()
+
+    def register_generic(self, generic, handler=None):
+        if handler is None:
+            return partial(self.register_generic, generic)
+        else:
+            self.generic_handlers.register(generic, handler)
+
+    def __call__(self, t, fn):
+        from .dependent import DependentType
+
+        if isinstance(t, str):
+            t = eval(t, getattr(fn, "__globals__", {}))
+
+        if t is type:
+            t = type[object]
+        elif t is typing.Any:
+            t = object
+        elif t is inspect._empty:
+            t = object
+        elif isinstance(t, typing._AnnotatedAlias):
+            t = t.__origin__
+
+        origin = getattr(t, "__origin__", None)
+        if UnionType and isinstance(t, UnionType):
+            return self(t.__args__, fn)
+        elif origin is type:
+            return t
+        elif origin and getattr(t, "__args__", None) is None:
+            return t
+        elif origin is not None:
+            try:
+                results = self.generic_handlers[origin]
+                results = list(results.items())
+                results.sort(key=lambda x: x[1], reverse=True)
+                assert results
+                rval = results[0][0](self, t, fn)
+                if isinstance(origin, type) and hasattr(rval, "with_bound"):
+                    rval = rval.with_bound(origin)
+                return rval
+            except KeyError:  # pragma: no cover
+                raise TypeError(f"ovld does not understand generic type {t}")
+        elif isinstance(t, tuple):
+            return Union[tuple(self(t2, fn) for t2 in t)]
+        elif isinstance(t, DependentType) and not t.bound:
+            raise UsageError(
+                f"Dependent type {t} has not been given a type bound. Please use Dependent[<bound>, {t}] instead."
+            )
+        else:
+            return t
+
+
+normalize_type = TypeNormalizer()
+
+
+@normalize_type.register_generic(typing.Union)
+def _(self, t, fn):
+    return self(t.__args__, fn)
 
 
 class MetaMC(type):
-    def __new__(T, name, order):
-        return super().__new__(T, name, (), {"order": order})
+    def __new__(T, name, handler):
+        return super().__new__(T, name, (), {"_handler": handler})
 
-    def __init__(cls, name, order):
-        pass
+    def __init__(cls, name, handler):
+        cls.__args__ = getattr(handler, "__args__", ())
 
-    def __typeorder__(cls, other):
-        order = cls.order(other)
-        if isinstance(order, bool):
-            return NotImplemented
-        else:
-            return order
+    def codegen(cls):
+        return cls._handler.codegen()
+
+    def __type_order__(cls, other):
+        return cls._handler.__type_order__(other)
+
+    def __is_supertype__(cls, other):
+        return cls._handler.__is_supertype__(other)
+
+    def __is_subtype__(cls, other):  # pragma: no cover
+        return cls._handler.__is_subtype__(other)
 
     def __subclasscheck__(cls, sub):
-        result = cls.order(sub)
-        if isinstance(result, TypeRelationship):
-            return result.order in (Order.MORE, Order.SAME)
+        return cls._handler.__subclasscheck__(sub)
+
+    def __instancecheck__(cls, obj):
+        return cls._handler.__instancecheck__(obj)
+
+    def __eq__(cls, other):
+        return (
+            type(cls) is type(other)
+            and type(cls._handler) is type(other._handler)
+            and cls._handler == other._handler
+        )
+
+    def __hash__(cls):
+        return hash(cls._handler)
+
+    def __and__(cls, other):
+        return Intersection[cls, other]
+
+    def __rand__(cls, other):
+        return Intersection[other, cls]
+
+    def __str__(self):
+        return str(self._handler)
+
+    __repr__ = __str__
+
+
+class SingleFunctionHandler:
+    def __init__(self, handler, args):
+        self.handler = handler
+        self.args = self.__args__ = args
+
+    def __type_order__(self, other):
+        results = self.handler(other, *self.args)
+        if isinstance(results, TypeRelationship):
+            return results.order
         else:
-            return result
+            return NotImplemented
+
+    def __is_supertype__(self, other):
+        results = self.handler(other, *self.args)
+        if isinstance(results, bool):
+            return results
+        elif isinstance(results, TypeRelationship):
+            return results.supertype
+        else:  # pragma: no cover
+            return NotImplemented
+
+    def __is_subtype__(self, other):  # pragma: no cover
+        results = self.handler(other, *self.args)
+        if isinstance(results, TypeRelationship):
+            return results.subtype
+        else:
+            return NotImplemented
+
+    def __subclasscheck__(self, sub):
+        return self.__is_supertype__(sub)
+
+    def __instancecheck__(self, obj):
+        return issubclass(type(obj), self)
+
+    def __str__(self):
+        args = ", ".join(map(clsstring, self.__args__))
+        return f"{self.handler.__name__}[{args}]"
 
 
 def class_check(condition):
@@ -87,7 +174,7 @@ def class_check(condition):
         condition: A function that takes a class as an argument and returns
             True or False depending on whether it matches some condition.
     """
-    return MetaMC(condition.__name__, condition)
+    return MetaMC(condition.__name__, SingleFunctionHandler(condition, ()))
 
 
 def parametrized_class_check(fn):
@@ -106,14 +193,10 @@ def parametrized_class_check(fn):
             if not isinstance(arg, tuple):
                 arg = (arg,)
 
-            def arg_to_str(x):
-                if isinstance(x, type):
-                    return x.__name__
-                else:
-                    return repr(x)
-
-            name = f"{fn.__name__}[{', '.join(map(arg_to_str, arg))}]"
-            return MetaMC(name, lambda sub: fn(sub, *arg))
+            if isinstance(fn, type):
+                return MetaMC(fn.__name__, fn(*arg))
+            else:
+                return MetaMC(fn.__name__, SingleFunctionHandler(fn, arg))
 
     _C.__name__ = fn.__name__
     _C.__qualname__ = fn.__qualname__
@@ -128,6 +211,56 @@ def _getcls(ref):
     return curr
 
 
+class AllMC(type):
+    def __type_order__(self, other):
+        return Order.MORE
+
+    def __is_subtype__(self, other):
+        return True
+
+    def __is_supertype__(self, other):
+        return False
+
+    def __subclasscheck__(self, other):  # pragma: no cover
+        return False
+
+    def __isinstance__(self, other):  # pragma: no cover
+        return False
+
+
+class All(metaclass=AllMC):
+    """All is the empty/void/bottom type -- it acts as a subtype of all types.
+
+    It is basically the opposite of Any: nothing is an instance of All. The main
+    place you want to use All is as a wildcard in contravariant settings, e.g.
+    all 2-argument functions are instances of Callable[[All, All], Any] because
+    the arguments are contravariant.
+    """
+
+
+class WhateverMC(AllMC):
+    def __is_supertype__(self, other):
+        return True
+
+    def __subclasscheck__(self, other):  # pragma: no cover
+        return True
+
+    def __isinstance__(self, other):  # pragma: no cover
+        return True
+
+
+class Whatever(metaclass=WhateverMC):
+    """This type is a superclass and a subclass of everything.
+
+    It's not a coherent type, more like a convenience.
+
+    It'll match anything anywhere, so you can write e.g.
+    Callable[[Whatever, Whatever], Whatever] to match any function of
+    two arguments. Any only works in covariant settings, and All only
+    works in contravariant settings.
+    """
+
+
 class Deferred:
     """Represent a class from an external module without importing it.
 
@@ -156,7 +289,7 @@ class Deferred:
             else:
                 return False
 
-        return MetaMC(f"Deferred[{ref}]", check)
+        return MetaMC(f"Deferred[{ref}]", SingleFunctionHandler(check, ()))
 
 
 @parametrized_class_check
@@ -164,7 +297,7 @@ def Exactly(cls, base_cls):
     """Match the class but not its subclasses."""
     return TypeRelationship(
         order=Order.LESS if cls is base_cls else typeorder(base_cls, cls),
-        matches=cls is base_cls,
+        supertype=cls is base_cls,
     )
 
 
@@ -179,16 +312,105 @@ def StrictSubclass(cls, base_cls):
 
 
 @parametrized_class_check
-def Intersection(cls, *classes):
-    """Match all classes."""
-    matches = all(subclasscheck(cls, t) for t in classes)
-    compare = [x for t in classes if (x := typeorder(t, cls)) is not Order.NONE]
-    if not compare:
-        return TypeRelationship(Order.NONE, matches=matches)
-    elif any(x is Order.LESS or x is Order.SAME for x in compare):
-        return TypeRelationship(Order.LESS, matches=matches)
-    else:
-        return TypeRelationship(Order.MORE, matches=matches)
+class Union:
+    def __init__(self, *types):
+        self.__args__ = self.types = types
+
+    def codegen(self):
+        from .dependent import combine, generate_checking_code
+
+        template = " or ".join("{}" for t in self.types)
+        return combine(
+            template, [generate_checking_code(t) for t in self.types]
+        )
+
+    def __type_order__(self, other):
+        if other is Union:
+            return Order.LESS
+        classes = self.types
+        compare = [
+            x for t in classes if (x := typeorder(t, other)) is not Order.NONE
+        ]
+        if not compare:
+            return Order.NONE
+        elif any(x is Order.MORE or x is Order.SAME for x in compare):
+            return Order.MORE
+        else:
+            return Order.LESS
+
+    def __is_supertype__(self, other):
+        return any(subclasscheck(other, t) for t in self.types)
+
+    def __is_subtype__(self, other):
+        if other is Union:
+            return True
+        return NotImplemented  # pragma: no cover
+
+    def __subclasscheck__(self, sub):
+        return self.__is_supertype__(sub)
+
+    def __instancecheck__(self, obj):
+        return any(isinstance(obj, t) for t in self.types)
+
+    def __eq__(self, other):
+        return self.__args__ == other.__args__
+
+    def __hash__(self):
+        return hash(self.__args__)
+
+    def __str__(self):
+        return " | ".join(map(clsstring, self.__args__))
+
+
+@parametrized_class_check
+class Intersection:
+    def __init__(self, *types):
+        self.__args__ = self.types = types
+
+    def codegen(self):
+        from .dependent import combine, generate_checking_code
+
+        template = " and ".join("{}" for t in self.types)
+        return combine(
+            template, [generate_checking_code(t) for t in self.types]
+        )
+
+    def __type_order__(self, other):
+        if other is Intersection:
+            return Order.LESS
+        classes = self.types
+        compare = [
+            x for t in classes if (x := typeorder(t, other)) 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
+
+    def __is_supertype__(self, other):
+        return all(subclasscheck(other, t) for t in self.types)
+
+    def __is_subtype__(self, other):  # pragma: no cover
+        if other is Intersection:
+            return True
+        return NotImplemented
+
+    def __subclasscheck__(self, sub):
+        return self.__is_supertype__(sub)
+
+    def __instancecheck__(self, obj):
+        return all(isinstance(obj, t) for t in self.types)
+
+    def __eq__(self, other):
+        return self.__args__ == other.__args__
+
+    def __hash__(self):
+        return hash(self.__args__)
+
+    def __str__(self):
+        return " & ".join(map(clsstring, self.__args__))
 
 
 @parametrized_class_check

ovld/utils.py

@@ -1,6 +1,7 @@
 """Miscellaneous utilities."""
 
 import functools
+import typing
 
 
 class Named:
@@ -60,6 +61,41 @@ class Unusable:
         raise UsageError(self.__message)
 
 
+class GenericAliasMC(type):
+    def __instancecheck__(cls, obj):
+        return hasattr(obj, "__origin__")
+
+
+class GenericAlias(metaclass=GenericAliasMC):
+    pass
+
+
+def clsstring(cls):
+    if cls is object:
+        return "*"
+    elif args := typing.get_args(cls):
+        origin = typing.get_origin(cls) or cls
+        args = ", ".join(map(clsstring, args))
+        return f"{origin.__name__}[{args}]"
+    else:
+        r = repr(cls)
+        if r.startswith("<class "):
+            return cls.__name__
+        else:
+            return r
+
+
+def subtler_type(obj):
+    if isinstance(obj, GenericAlias):
+        return type[obj]
+    elif obj is typing.Any:
+        return type[object]
+    elif isinstance(obj, type):
+        return type[obj]
+    else:
+        return type(obj)
+
+
 __all__ = [
     "BOOTSTRAP",
     "MISSING",

ovld/version.py

@@ -1 +1 @@
-version = "0.4.2"
+version = "0.4.4"

{ovld-0.4.2.dist-info → ovld-0.4.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ovld
-Version: 0.4.2
+Version: 0.4.4
 Summary: Overloading Python functions
 Project-URL: Homepage, https://ovld.readthedocs.io/en/latest/
 Project-URL: Documentation, https://ovld.readthedocs.io/en/latest/

ovld-0.4.4.dist-info/RECORD

@@ -0,0 +1,14 @@
+ovld/__init__.py,sha256=GEhOdG64GPUY5Y5BMnaik7UMgcq12mWVhxN9quIonYw,1476
+ovld/abc.py,sha256=4qpZyYwI8dWgY1Oiv5FhdKg2uzNcyWxIpGmGJVcjXrs,1177
+ovld/core.py,sha256=vzrYgUdagsQH6gbw32kzYzd-MvnCE3O9LjUyc-vVk1M,25366
+ovld/dependent.py,sha256=vvWjjOHNtw8PegZVDj1fRKpyp6SCg1WdOWoXNxZSVrk,9288
+ovld/mro.py,sha256=0cJK_v-POCiuwjluwf8fWeQ3G-2chEUv3KYe57GC61Q,4552
+ovld/recode.py,sha256=NWAM0qyOQqXgVCZxtmhtnkygWe-NV5FRwdXGtqikGTg,18494
+ovld/typemap.py,sha256=PH5dy8ddVCcqj2TkQbgsM7fmCdHsJT9WGXFPn4JZsCA,13131
+ovld/types.py,sha256=EZNv8pThbo47KBULYM3R0R3sM2C5LC4DWraXZImkiNs,12877
+ovld/utils.py,sha256=BsE7MmW5sfnO4Ym8hcEL8JNZZ1JIX_pgVRAAidh_8_w,2085
+ovld/version.py,sha256=Qk6wsgzl7cSMWWZ902odoQ-wBV5Fda2ShX82NN7uHzM,18
+ovld-0.4.4.dist-info/METADATA,sha256=wUsEDZyoQPooCN7P7q4MyObKAeSjg7DqpR-vRne5BW8,7713
+ovld-0.4.4.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+ovld-0.4.4.dist-info/licenses/LICENSE,sha256=cSwNTIzd1cbI89xt3PeZZYJP2y3j8Zus4bXgo4svpX8,1066
+ovld-0.4.4.dist-info/RECORD,,

ovld-0.4.2.dist-info/RECORD

@@ -1,13 +0,0 @@
-ovld/__init__.py,sha256=Vp9wbIy_opFmJx-vCcToQcIP3cWFIvgbfYHITyiwPLs,1305
-ovld/core.py,sha256=glexOiRU0ajoxFAQN6d69ToL6_cPvyv05Z7LEHqrJj8,25701
-ovld/dependent.py,sha256=QITsWu2uCwqkHE0tunETy8Jqwc272uoG5YM0I5yy0m4,7303
-ovld/mro.py,sha256=rS0pCLLWwLUI0NdthpoJSrdvWR4-XgRfx1pLAvJde14,5586
-ovld/recode.py,sha256=zxhyotuc73qzuN4NEN_rKxaqoA0SOH7KFtE2l_CRBFs,17963
-ovld/typemap.py,sha256=gw8XvB-N_15Dr0-am0v17x1seNjYK5AxvUT9L36mWic,13630
-ovld/types.py,sha256=Zeb7xhHbL4T7qIRHI-I_cjG61UIWrfZv_EwjwqhB-rY,6381
-ovld/utils.py,sha256=V6Y8oZ6ojq8JaODL1rMZbU5L9QG0YSqHNYmpIFiwy3M,1294
-ovld/version.py,sha256=OHlqRD04Kvw_CFYmiIVx7UuOJRTQKtAx1Bl4rkUYHJE,18
-ovld-0.4.2.dist-info/METADATA,sha256=fV3vxTKRAjCUkRVNmzTW14VajGSl7P0b9NnG06cjUJk,7713
-ovld-0.4.2.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-ovld-0.4.2.dist-info/licenses/LICENSE,sha256=cSwNTIzd1cbI89xt3PeZZYJP2y3j8Zus4bXgo4svpX8,1066
-ovld-0.4.2.dist-info/RECORD,,