effectful 0.0.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

effectful/handlers/numbers.py

@@ -1,259 +0,0 @@
-import numbers
-import operator
-from typing import Any, TypeVar
-
-from typing_extensions import ParamSpec
-
-from effectful.ops.syntax import NoDefaultRule, defdata, defop, syntactic_eq
-from effectful.ops.types import Operation, Term
-
-P = ParamSpec("P")
-Q = ParamSpec("Q")
-S = TypeVar("S")
-T = TypeVar("T")
-V = TypeVar("V")
-
-T_Number = TypeVar("T_Number", bound=numbers.Number)
-
-
-@defdata.register(numbers.Number)
-@numbers.Number.register
-class _NumberTerm(Term[numbers.Number]):
-    def __init__(
-        self, op: Operation[..., numbers.Number], args: tuple, kwargs: dict
-    ) -> None:
-        self._op = op
-        self._args = args
-        self._kwargs = kwargs
-
-    @property
-    def op(self) -> Operation[..., numbers.Number]:
-        return self._op
-
-    @property
-    def args(self) -> tuple:
-        return self._args
-
-    @property
-    def kwargs(self) -> dict:
-        return self._kwargs
-
-    def __hash__(self):
-        return hash((self.op, tuple(self.args), tuple(self.kwargs.items())))
-
-
-# Complex specific methods
-@defop
-def eq(x: T_Number, y: T_Number) -> bool:
-    if not any(isinstance(a, Term) for a in (x, y)):
-        return operator.eq(x, y)
-    else:
-        return syntactic_eq(x, y)
-
-
-def _wrap_cmp(op):
-    def _wrapped_op(x: T_Number, y: T_Number) -> bool:
-        if not any(isinstance(a, Term) for a in (x, y)):
-            return op(x, y)
-        else:
-            raise NoDefaultRule
-
-    _wrapped_op.__name__ = op.__name__
-    return _wrapped_op
-
-
-def _wrap_binop(op):
-    def _wrapped_op(x: T_Number, y: T_Number) -> T_Number:
-        if not any(isinstance(a, Term) for a in (x, y)):
-            return op(x, y)
-        else:
-            raise NoDefaultRule
-
-    _wrapped_op.__name__ = op.__name__
-    return _wrapped_op
-
-
-def _wrap_unop(op):
-    def _wrapped_op(x: T_Number) -> T_Number:
-        if not isinstance(x, Term):
-            return op(x)
-        else:
-            raise NoDefaultRule
-
-    _wrapped_op.__name__ = op.__name__
-    return _wrapped_op
-
-
-add = defop(_wrap_binop(operator.add))
-neg = defop(_wrap_unop(operator.neg))
-pos = defop(_wrap_unop(operator.pos))
-sub = defop(_wrap_binop(operator.sub))
-mul = defop(_wrap_binop(operator.mul))
-truediv = defop(_wrap_binop(operator.truediv))
-pow = defop(_wrap_binop(operator.pow))
-abs = defop(_wrap_unop(operator.abs))
-
-
-@defdata.register(numbers.Complex)
-@numbers.Complex.register
-class _ComplexTerm(_NumberTerm, Term[numbers.Complex]):
-    def __bool__(self) -> bool:
-        raise ValueError("Cannot convert term to bool")
-
-    def __add__(self, other: Any) -> numbers.Real:
-        return add(self, other)
-
-    def __radd__(self, other: Any) -> numbers.Real:
-        return add(other, self)
-
-    def __neg__(self):
-        return neg(self)
-
-    def __pos__(self):
-        return pos(self)
-
-    def __sub__(self, other: Any) -> numbers.Real:
-        return sub(self, other)
-
-    def __rsub__(self, other: Any) -> numbers.Real:
-        return sub(other, self)
-
-    def __mul__(self, other: Any) -> numbers.Real:
-        return mul(self, other)
-
-    def __rmul__(self, other: Any) -> numbers.Real:
-        return mul(other, self)
-
-    def __truediv__(self, other: Any) -> numbers.Real:
-        return truediv(self, other)
-
-    def __rtruediv__(self, other: Any) -> numbers.Real:
-        return truediv(other, self)
-
-    def __pow__(self, other: Any) -> numbers.Real:
-        return pow(self, other)
-
-    def __rpow__(self, other: Any) -> numbers.Real:
-        return pow(other, self)
-
-    def __abs__(self) -> numbers.Real:
-        return abs(self)
-
-    def __eq__(self, other: Any) -> bool:
-        return eq(self, other)
-
-
-# Real specific methods
-floordiv = defop(_wrap_binop(operator.floordiv))
-mod = defop(_wrap_binop(operator.mod))
-lt = defop(_wrap_cmp(operator.lt))
-le = defop(_wrap_cmp(operator.le))
-gt = defop(_wrap_cmp(operator.gt))
-ge = defop(_wrap_cmp(operator.ge))
-
-
-@defdata.register(numbers.Real)
-@numbers.Real.register
-class _RealTerm(_ComplexTerm, Term[numbers.Real]):
-    # Real specific methods
-    def __float__(self) -> float:
-        raise ValueError("Cannot convert term to float")
-
-    def __trunc__(self) -> numbers.Integral:
-        raise NotImplementedError
-
-    def __floor__(self) -> numbers.Integral:
-        raise NotImplementedError
-
-    def __ceil__(self) -> numbers.Integral:
-        raise NotImplementedError
-
-    def __round__(self, ndigits=None) -> numbers.Integral:
-        raise NotImplementedError
-
-    def __floordiv__(self, other):
-        return floordiv(self, other)
-
-    def __rfloordiv__(self, other):
-        return floordiv(other, self)
-
-    def __mod__(self, other):
-        return mod(self, other)
-
-    def __rmod__(self, other):
-        return mod(other, self)
-
-    def __lt__(self, other):
-        return lt(self, other)
-
-    def __le__(self, other):
-        return le(self, other)
-
-
-@defdata.register(numbers.Rational)
-@numbers.Rational.register
-class _RationalTerm(_RealTerm, Term[numbers.Rational]):
-    @property
-    def numerator(self):
-        raise NotImplementedError
-
-    @property
-    def denominator(self):
-        raise NotImplementedError
-
-
-# Integral specific methods
-index = defop(_wrap_unop(operator.index))
-lshift = defop(_wrap_binop(operator.lshift))
-rshift = defop(_wrap_binop(operator.rshift))
-and_ = defop(_wrap_binop(operator.and_))
-xor = defop(_wrap_binop(operator.xor))
-or_ = defop(_wrap_binop(operator.or_))
-invert = defop(_wrap_unop(operator.invert))
-
-
-@defdata.register(numbers.Integral)
-@numbers.Integral.register
-class _IntegralTerm(_RationalTerm, Term[numbers.Integral]):
-    # Integral specific methods
-    def __int__(self) -> int:
-        raise ValueError("Cannot convert term to int")
-
-    def __index__(self) -> numbers.Integral:
-        return index(self)
-
-    def __pow__(self, exponent: Any, modulus=None) -> numbers.Integral:
-        return pow(self, exponent)
-
-    def __lshift__(self, other):
-        return lshift(self, other)
-
-    def __rlshift__(self, other):
-        return lshift(other, self)
-
-    def __rshift__(self, other):
-        return rshift(self, other)
-
-    def __rrshift__(self, other):
-        return rshift(other, self)
-
-    def __and__(self, other):
-        return and_(self, other)
-
-    def __rand__(self, other):
-        return and_(other, self)
-
-    def __xor__(self, other):
-        return xor(self, other)
-
-    def __rxor__(self, other):
-        return xor(other, self)
-
-    def __or__(self, other):
-        return or_(self, other)
-
-    def __ror__(self, other):
-        return or_(other, self)
-
-    def __invert__(self):
-        return invert(self)

effectful/internals/base_impl.py

@@ -1,259 +0,0 @@
-import collections
-import functools
-import inspect
-import typing
-from typing import Callable, Generic, Mapping, Sequence, Set, Type, TypeVar
-
-import tree
-from typing_extensions import ParamSpec
-
-from effectful.ops.types import Expr, Operation, Term
-
-P = ParamSpec("P")
-Q = ParamSpec("Q")
-S = TypeVar("S")
-T = TypeVar("T")
-V = TypeVar("V")
-
-
-def rename(
-    subs: Mapping[Operation[..., S], Operation[..., S]],
-    leaf_value: V,  # Union[Term[V], Operation[..., V], V],
-) -> V:  # Union[Term[V], Operation[..., V], V]:
-    from effectful.internals.runtime import interpreter
-    from effectful.ops.semantics import apply, evaluate
-
-    if isinstance(leaf_value, Operation):
-        return subs.get(leaf_value, leaf_value)  # type: ignore
-    elif isinstance(leaf_value, Term):
-        with interpreter(
-            {apply: lambda _, op, *a, **k: op.__free_rule__(*a, **k), **subs}
-        ):
-            return evaluate(leaf_value)  # type: ignore
-    else:
-        return leaf_value
-
-
-class _BaseOperation(Generic[Q, V], Operation[Q, V]):
-    signature: Callable[Q, V]
-
-    def __init__(self, signature: Callable[Q, V]):
-        functools.update_wrapper(self, signature)
-        self.signature = signature
-
-    def __eq__(self, other):
-        if not isinstance(other, Operation):
-            return NotImplemented
-        return self.signature == other.signature
-
-    def __hash__(self):
-        return hash(self.signature)
-
-    def __default_rule__(self, *args: Q.args, **kwargs: Q.kwargs) -> "Expr[V]":
-        from effectful.ops.syntax import NoDefaultRule
-
-        try:
-            return self.signature(*args, **kwargs)
-        except NoDefaultRule:
-            return self.__free_rule__(*args, **kwargs)
-
-    def __free_rule__(self, *args: Q.args, **kwargs: Q.kwargs) -> "Expr[V]":
-        from effectful.ops.syntax import Bound, Scoped, defdata, defop
-
-        sig = inspect.signature(self.signature)
-        bound_sig = sig.bind(*args, **kwargs)
-        bound_sig.apply_defaults()
-
-        bound_vars: dict[int, set[Operation]] = collections.defaultdict(set)
-        scoped_args: dict[int, set[str]] = collections.defaultdict(set)
-        unscoped_args: set[str] = set()
-        for param_name, param in bound_sig.signature.parameters.items():
-            if typing.get_origin(param.annotation) is typing.Annotated:
-                for anno in param.annotation.__metadata__:
-                    if isinstance(anno, Bound):
-                        scoped_args[anno.scope].add(param_name)
-                        if param.kind is inspect.Parameter.VAR_POSITIONAL:
-                            assert isinstance(bound_sig.arguments[param_name], tuple)
-                            for bound_var in bound_sig.arguments[param_name]:
-                                bound_vars[anno.scope].add(bound_var)
-                        elif param.kind is inspect.Parameter.VAR_KEYWORD:
-                            assert isinstance(bound_sig.arguments[param_name], dict)
-                            for bound_var in bound_sig.arguments[param_name].values():
-                                bound_vars[anno.scope].add(bound_var)
-                        else:
-                            bound_vars[anno.scope].add(bound_sig.arguments[param_name])
-                    elif isinstance(anno, Scoped):
-                        scoped_args[anno.scope].add(param_name)
-            else:
-                unscoped_args.add(param_name)
-
-        # TODO replace this temporary check with more general scope level propagation
-        if bound_vars:
-            min_scope = min(bound_vars.keys(), default=0)
-            scoped_args[min_scope] |= unscoped_args
-            max_scope = max(bound_vars.keys(), default=0)
-            assert all(s in bound_vars or s > max_scope for s in scoped_args.keys())
-
-        # recursively rename bound variables from innermost to outermost scope
-        for scope in sorted(bound_vars.keys()):
-            # create fresh variables for each bound variable in the scope
-            renaming_map = {var: defop(var) for var in bound_vars[scope]}
-            # get just the arguments that are in the scope
-            for name in scoped_args[scope]:
-                bound_sig.arguments[name] = tree.map_structure(
-                    lambda a: rename(renaming_map, a),
-                    bound_sig.arguments[name],
-                )
-
-        return defdata(_BaseTerm(self, bound_sig.args, bound_sig.kwargs))
-
-    def __type_rule__(self, *args: Q.args, **kwargs: Q.kwargs) -> Type[V]:
-        sig = inspect.signature(self.signature)
-        bound_sig = sig.bind(*args, **kwargs)
-        bound_sig.apply_defaults()
-
-        anno = sig.return_annotation
-        if anno is inspect.Signature.empty:
-            return typing.cast(Type[V], object)
-        elif isinstance(anno, typing.TypeVar):
-            # rudimentary but sound special-case type inference sufficient for syntax ops:
-            # if the return type annotation is a TypeVar,
-            # look for a parameter with the same annotation and return its type,
-            # otherwise give up and return Any/object
-            for name, param in bound_sig.signature.parameters.items():
-                if param.annotation is anno and param.kind not in (
-                    inspect.Parameter.VAR_POSITIONAL,
-                    inspect.Parameter.VAR_KEYWORD,
-                ):
-                    arg = bound_sig.arguments[name]
-                    tp: Type[V] = type(arg) if not isinstance(arg, type) else arg
-                    return tp
-            return typing.cast(Type[V], object)
-        elif typing.get_origin(anno) is typing.Annotated:
-            tp = typing.get_args(anno)[0]
-            if not typing.TYPE_CHECKING:
-                tp = tp if typing.get_origin(tp) is None else typing.get_origin(tp)
-            return tp
-        elif typing.get_origin(anno) is not None:
-            return typing.get_origin(anno)
-        else:
-            return anno
-
-    def __fvs_rule__(self, *args: Q.args, **kwargs: Q.kwargs) -> Set[Operation]:
-        from effectful.ops.syntax import Bound
-
-        sig = inspect.signature(self.signature)
-        bound_sig = sig.bind(*args, **kwargs)
-        bound_sig.apply_defaults()
-
-        bound_vars: Set[Operation] = set()
-        for param_name, param in bound_sig.signature.parameters.items():
-            if typing.get_origin(param.annotation) is typing.Annotated:
-                for anno in param.annotation.__metadata__:
-                    if isinstance(anno, Bound):
-                        if param.kind is inspect.Parameter.VAR_POSITIONAL:
-                            for bound_var in bound_sig.arguments[param_name]:
-                                bound_vars.add(bound_var)
-                        elif param.kind is inspect.Parameter.VAR_KEYWORD:
-                            for bound_var in bound_sig.arguments[param_name].values():
-                                bound_vars.add(bound_var)
-                        else:
-                            bound_var = bound_sig.arguments[param_name]
-                            bound_vars.add(bound_var)
-
-        return bound_vars
-
-    def __repr_rule__(self, *args: Q.args, **kwargs: Q.kwargs) -> str:
-        args_str = ", ".join(map(str, args)) if args else ""
-        kwargs_str = (
-            ", ".join(f"{k}={str(v)}" for k, v in kwargs.items()) if kwargs else ""
-        )
-
-        ret = f"{self.signature.__name__}({args_str}"
-        if kwargs:
-            ret += f"{', ' if args else ''}"
-        ret += f"{kwargs_str})"
-        return ret
-
-    def __repr__(self):
-        return self.signature.__name__
-
-
-class _BaseTerm(Generic[T], Term[T]):
-    _op: Operation[..., T]
-    _args: Sequence[Expr]
-    _kwargs: Mapping[str, Expr]
-
-    def __init__(
-        self,
-        op: Operation[..., T],
-        args: Sequence[Expr],
-        kwargs: Mapping[str, Expr],
-    ):
-        self._op = op
-        self._args = args
-        self._kwargs = kwargs
-
-    def __eq__(self, other) -> bool:
-        from effectful.ops.syntax import syntactic_eq
-
-        return syntactic_eq(self, other)
-
-    @property
-    def op(self):
-        return self._op
-
-    @property
-    def args(self):
-        return self._args
-
-    @property
-    def kwargs(self):
-        return self._kwargs
-
-
-class _CallableTerm(Generic[P, T], _BaseTerm[collections.abc.Callable[P, T]]):
-    def __call__(self, *args: Expr, **kwargs: Expr) -> Expr[T]:
-        from effectful.ops.semantics import call
-
-        return call(self, *args, **kwargs)  # type: ignore
-
-
-def _unembed_callable(value: Callable[P, T]) -> Expr[Callable[P, T]]:
-    from effectful.internals.runtime import interpreter
-    from effectful.ops.semantics import apply, call
-    from effectful.ops.syntax import deffn, defop
-
-    assert not isinstance(value, Term)
-
-    try:
-        sig = inspect.signature(value)
-    except ValueError:
-        return value
-
-    for name, param in sig.parameters.items():
-        if param.kind in (
-            inspect.Parameter.VAR_POSITIONAL,
-            inspect.Parameter.VAR_KEYWORD,
-        ):
-            raise NotImplementedError(
-                f"cannot unembed {value}: parameter {name} is variadic"
-            )
-
-    bound_sig = sig.bind(
-        **{name: defop(param.annotation) for name, param in sig.parameters.items()}
-    )
-    bound_sig.apply_defaults()
-
-    with interpreter(
-        {
-            apply: lambda _, op, *a, **k: op.__free_rule__(*a, **k),
-            call: call.__default_rule__,
-        }
-    ):
-        body = value(
-            *[a() for a in bound_sig.args],
-            **{k: v() for k, v in bound_sig.kwargs.items()},
-        )
-
-    return deffn(body, *bound_sig.args, **bound_sig.kwargs)

effectful-0.0.1.dist-info/RECORD

@@ -1,19 +0,0 @@
-effectful/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-effectful/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-effectful/handlers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-effectful/handlers/indexed.py,sha256=lNqlHZqD8JBs-KaC3YdCoQDAXHuQ9KhAH0ZhpIqMdFM,13184
-effectful/handlers/numbers.py,sha256=aKVCJ-l3ISvOGHTfXsQIEp4uEsQsYy7bP-YUCsSO_3o,6557
-effectful/handlers/pyro.py,sha256=s_CAXe65gqXmKiYLUXJ0_uLQzEEgyQbZv0hQWMMdQJ4,15312
-effectful/handlers/torch.py,sha256=LJYwud6Dq3xg7A6_6aaDEyP1hT0IB4G_55Gki6izRvo,18401
-effectful/internals/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-effectful/internals/base_impl.py,sha256=6Yxxg5tS_R2RLlHvtOhj_fuA_9hEa_YKf0LhQOX2448,9671
-effectful/internals/runtime.py,sha256=E0ce5mfG0-DlTeALYZePWtdxr0AK3y0CPl_LE5pp_0k,1908
-effectful/ops/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-effectful/ops/semantics.py,sha256=Ihaj2ycildtMg18GSujSJSaAAKsArKoyMmR-gBoWx8E,10208
-effectful/ops/syntax.py,sha256=nRfguHAol5lDnUv0UMOB0AL6y6By2DCW7hlCYsN3OnM,15331
-effectful/ops/types.py,sha256=DmVqX8naWNQEW1A6w7ShrXp_LZV6qoK4p_OAM3NitTI,3241
-effectful-0.0.1.dist-info/LICENSE.md,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-effectful-0.0.1.dist-info/METADATA,sha256=WN7j_mJwZao1T1MTWyAIo_1hP6YUCS4L6rPI9wWCScA,4930
-effectful-0.0.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-effectful-0.0.1.dist-info/top_level.txt,sha256=gtuJfrE2nXil_lZLCnqWF2KAbOnJs9ILNvK8WnkRzbs,10
-effectful-0.0.1.dist-info/RECORD,,