ovld 0.3.8__tar.gz → 0.3.9__tar.gz

ovld-0.3.9/.envrc

@@ -0,0 +1,2 @@
+. .venv/bin/activate
+export PYTHONBREAKPOINT=breakword.breakpoint

{ovld-0.3.8 → ovld-0.3.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ovld
-Version: 0.3.8
+Version: 0.3.9
 Summary: Overloading Python functions
 Author-email: Olivier Breuleux <breuleux@gmail.com>
 License-Expression: MIT
@@ -19,7 +19,7 @@ Other features of `ovld`:
 
 * Multiple dispatch for methods (with `metaclass=ovld.OvldMC`)
 * Create variants of functions
-* Built-in support for extensible, stateful recursion
+* Built-in support for extensible recursion
 * Function wrappers
 * Function postprocessors
 * Nice stack traces
@@ -84,22 +84,6 @@ assert mul([1, 2], [3, 4]) == [3, 8]
 
 A `variant` of a function is a copy which inherits all of the original's implementations but may define new ones. And because `self` is bound to the function that's called at the top level, the implementations for `list`, `tuple` and `dict` will bind `self` to `add` or `mul` depending on which one was called. You may also call `self.super(*args)` to invoke the parent implementation for that type.
 
-## State
-
-You can pass `initial_state` to `@ovld` or `variant`. The initial state must be a function that takes no arguments. Its return value will be available in `self.state`. The state is initialized at the top level call, but recursive calls to `self` will preserve it.
-
-In other words, you can do something like this:
-
-```python
-@add.variant(initial_state=lambda: 0)
-def count(self, x, y):
-    self.state += 1
-    return (f"#{self.state}", x + y)
-
-assert count([1, 2, 3], [4, 5, 6]) == [("#1", 5), ("#2", 7), ("#3", 9)]
-```
-
-The initial_state function can return any object and you can use the state to any purpose (e.g. cache or memoization).
 
 ## Custom dispatch
 
@@ -134,7 +118,7 @@ assert add_default([1, 2, "alouette"]) == [2, 4, "alouettealouette"]
 
 There are other uses for this feature, e.g. memoization.
 
-The normal functions may also have a `self`, which works the same as bootstrapping, and you can give an `initial_state` to `@ovld.dispatch` as well.
+The normal functions may also have a `self`, which works the same as bootstrapping.
 
 ## Postprocess
 

{ovld-0.3.8 → ovld-0.3.9}/README.md

@@ -9,7 +9,7 @@ Other features of `ovld`:
 
 * Multiple dispatch for methods (with `metaclass=ovld.OvldMC`)
 * Create variants of functions
-* Built-in support for extensible, stateful recursion
+* Built-in support for extensible recursion
 * Function wrappers
 * Function postprocessors
 * Nice stack traces
@@ -74,22 +74,6 @@ assert mul([1, 2], [3, 4]) == [3, 8]
 
 A `variant` of a function is a copy which inherits all of the original's implementations but may define new ones. And because `self` is bound to the function that's called at the top level, the implementations for `list`, `tuple` and `dict` will bind `self` to `add` or `mul` depending on which one was called. You may also call `self.super(*args)` to invoke the parent implementation for that type.
 
-## State
-
-You can pass `initial_state` to `@ovld` or `variant`. The initial state must be a function that takes no arguments. Its return value will be available in `self.state`. The state is initialized at the top level call, but recursive calls to `self` will preserve it.
-
-In other words, you can do something like this:
-
-```python
-@add.variant(initial_state=lambda: 0)
-def count(self, x, y):
-    self.state += 1
-    return (f"#{self.state}", x + y)
-
-assert count([1, 2, 3], [4, 5, 6]) == [("#1", 5), ("#2", 7), ("#3", 9)]
-```
-
-The initial_state function can return any object and you can use the state to any purpose (e.g. cache or memoization).
 
 ## Custom dispatch
 
@@ -124,7 +108,7 @@ assert add_default([1, 2, "alouette"]) == [2, 4, "alouettealouette"]
 
 There are other uses for this feature, e.g. memoization.
 
-The normal functions may also have a `self`, which works the same as bootstrapping, and you can give an `initial_state` to `@ovld.dispatch` as well.
+The normal functions may also have a `self`, which works the same as bootstrapping.
 
 ## Postprocess
 

{ovld-0.3.8 → ovld-0.3.9}/bench.py

@@ -2,7 +2,8 @@ import timeit
 
 from multimethod import multimethod
 from multipledispatch import dispatch
-from ovld import ovld
+
+from ovld import ovld, recurse
 
 # OVLD
 
@@ -52,6 +53,30 @@ def smap_b(self, x: object, y: object):
     return x + y
 
 
+# OVLD C
+
+
+@ovld
+def smap_c(x: list, y: list):
+    """Two."""
+    return [recurse(a, b) for a, b in zip(x, y)]
+
+
+@ovld
+def smap_c(x: tuple, y: tuple):
+    return tuple(recurse(a, b) for a, b in zip(x, y))
+
+
+@ovld
+def smap_c(x: dict, y: dict):
+    return {k: recurse(v, y[k]) for k, v in x.items()}
+
+
+@ovld
+def smap_c(x: object, y: object):
+    return x + y
+
+
 # multimethods
 
 
@@ -121,11 +146,20 @@ def smap_ii(x, y):
 A = {"xs": list(range(50)), "ys": ("o", (6, 7))}
 B = {"xs": list(range(10, 60)), "ys": ("x", (7, 6))}
 
-print(smap(A, B))
-print(smap_mm(A, B))
-print(smap_md(A, B))
-print(smap_ii(A, B))
-print(smap_b(A, B))
+results = {
+    "smap": smap(A, B),
+    "smap_mm": smap_mm(A, B),
+    "smap_md": smap_md(A, B),
+    "smap_ii": smap_ii(A, B),
+    "smap_b": smap_b(A, B),
+    "smap_c": smap_c(A, B),
+}
+
+expected = results["smap"]
+
+for k, v in results.items():
+    assert v == expected, f"{k} failed"
+
 
 # breakpoint()
 
@@ -134,3 +168,4 @@ print("smap_mm\t", timeit.timeit(lambda: smap_mm(A, B), number=10000))
 print("smap_md\t", timeit.timeit(lambda: smap_md(A, B), number=10000))
 print("smap_ii\t", timeit.timeit(lambda: smap_ii(A, B), number=10000))
 print("smap_b\t", timeit.timeit(lambda: smap_b(A, B), number=10000))
+print("smap_c\t", timeit.timeit(lambda: smap_c(A, B), number=10000))

ovld-0.3.9/doo.py

@@ -0,0 +1,74 @@
+from enum import Enum
+from types import UnionType
+
+from ovld import ovld
+from ovld.core import OvldBase
+
+
+class Poof[T]:
+    pass
+
+
+class Flax(OvldBase):
+    @ovld
+    def f(self, x: object, y: type[Poof[object]]):
+        return 1234
+
+    def f(self, frm: int, to: type[int]):
+        return to(frm)
+
+    def f(self, frm: float, to: type[float]):
+        return to(frm)
+
+    def f(self, frm: str, to: type[str]):
+        return to(frm)
+
+    def f(self, frm: str, to: type[Enum]):
+        return to(frm)
+
+    def f(self, frm: object, to: UnionType):
+        for t in to.__args__:
+            try:
+                return self.deserialize(frm, t)
+            except TypeError:
+                continue
+        else:
+            return self.deserialize.next(frm, to)
+
+    def f(self, frm: dict, to: type[Poof[object]]):
+        model = self.model(to)
+        if model is NotImplemented:
+            return self.deserialize.next(frm, to)
+        else:
+            des = {
+                k: self.deserialize(v, model.fields_by_name[k].type)
+                for k, v in frm.items()
+            }
+            return model.builder(**des)
+
+    def f(self, frm: dict, to: type[object]):
+        model = self.model(to)
+        if model is NotImplemented:
+            return self.deserialize.next(frm, to)
+        else:
+            return self.deserialize(frm, model)
+
+    # def f(self, frm: dict, typ: Model):
+    #     des = {k: self.deserialize(v, typ.fields_by_name[k].type) for k, v in frm.items()}
+    #     return typ.builder(**des)
+
+
+@ovld
+def f(x: object, y: type[Poof[object]]):
+    return 12345
+
+
+print(f(3, Poof[int]))
+print(Flax().f(3, Poof[int]))
+
+
+# print("=" * 80)
+# print(compose_mro(list[int], {list[object]}, set()))
+
+# print("=" * 80)
+# print(compose_mro(Poof[int], {Poof[object]}, set()))

ovld-0.3.9/edges.py

@@ -0,0 +1,64 @@
+from dataclasses import dataclass
+from typing import Protocol, runtime_checkable
+
+from ovld import Dataclass, ovld
+
+
+@runtime_checkable
+class SupportsRead(Protocol):
+    def read(self, amount: int) -> bytes: ...
+
+
+@runtime_checkable
+class SupportsWrite(Protocol):
+    def write(self, amount: int) -> bytes: ...
+
+
+@dataclass
+class Reader:
+    def read(self):
+        return 1
+
+    def write(self):
+        return 1
+
+
+@dataclass
+class Writer:
+    def write(self):
+        return 1
+
+
+@ovld
+def f(x: SupportsRead):
+    return "yes"
+
+
+@ovld
+def f(x: SupportsWrite):
+    return "yes"
+
+
+# @ovld
+# def f(x: Reader):
+#     return "R" + f.next(x)
+
+
+@ovld  # (priority=-1)
+def f(x: Dataclass):
+    return "DC"
+
+
+@ovld
+def f(x: int):
+    return "w/e"
+
+
+@ovld
+def f(x):
+    return "no"
+
+
+# print(f(1))
+print(f(Reader()))
+# print(f(Writer()))

ovld-0.3.9/explore.py

@@ -0,0 +1,69 @@
+# import dis
+
+# z = 10
+
+
+# def foo(x):
+#     def faf(y):
+#         return x + y + z
+
+#     return faf
+
+
+# fn = foo(4)
+
+# bytecode = dis.Bytecode(fn)
+# print("=" * 80)
+# for instr in bytecode:
+#     print(instr)
+
+# breakpoint()
+
+
+from wrapt import ObjectProxy
+
+from ovld import ovld, recurse
+
+
+class AnnotatedProxy(ObjectProxy):
+    def __init__(self, wrapped, **ann):
+        super().__init__(wrapped)
+        self._self_ann = ann
+
+    @property
+    def _(self):
+        return self._self_ann
+
+
+# @ovld(priority=10)
+# def f(x: object):
+#     return recurse.next(x)
+
+
+@ovld
+def f(xs: list):
+    return [recurse(x) for x in xs]
+
+
+@ovld
+def f(xs: dict):
+    return {recurse(k): recurse(v) for k, v in xs.items()}
+
+
+@ovld
+def f(x: str):
+    return x
+
+
+@ovld
+def f(x: int):
+    return x / 0
+
+
+# # f({"a": [[[[1, 2, 3]]]]})
+# # breakpoint()
+# res = f({"a": [[[[1, 2, 3]]]]})
+# print(res)
+
+# data = {"a": 2}
+# print(f(AnnotatedProxy(data, x=4)))

ovld-0.3.9/nxt.py

@@ -0,0 +1,13 @@
+from ovld import OvldBase, ovld
+
+
+class Boop(OvldBase):
+    @ovld(priority=100)
+    def f(self, x: object):
+        return self.f.next(x) * 3
+
+    def f(self, x: int):
+        return x * 2
+
+
+print(Boop().f(7))

{ovld-0.3.8 → ovld-0.3.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ovld"
-version = "0.3.8"
+version = "0.3.9"
 description = "Overloading Python functions"
 authors = [
     { name = "Olivier Breuleux", email = "breuleux@gmail.com" }