egglog 6.0.1__cp311-none-win_amd64.whl → 7.0.0__cp311-none-win_amd64.whl

egglog/__init__.py

@@ -4,7 +4,7 @@ Package for creating e-graphs in Python.
 
 from . import config, ipython_magic  # noqa: F401
 from .builtins import *  # noqa: UP029
+from .conversion import convert, converter  # noqa: F401
 from .egraph import *
-from .runtime import convert, converter  # noqa: F401
 
 del ipython_magic

egglog/bindings.pyi

@@ -29,7 +29,9 @@ class EGraph:
         fact_directory: str | Path | None = None,
         seminaive: bool = True,
         terms_encoding: bool = False,
+        record: bool = False,
     ) -> None: ...
+    def commands(self) -> str | None: ...
     def parse_program(self, __input: str, /) -> list[_Command]: ...
     def run_program(self, *commands: _Command) -> list[str]: ...
     def extract_report(self) -> _ExtractReport | None: ...
@@ -150,6 +152,20 @@ class Fact:
 
 _Fact: TypeAlias = Fact | Eq
 
+##
+# Change
+##
+
+@final
+class Delete:
+    def __init__(self) -> None: ...
+
+@final
+class Subsume:
+    def __init__(self) -> None: ...
+
+_Change: TypeAlias = Delete | Subsume
+
 ##
 # Actions
 ##
@@ -168,10 +184,11 @@ class Set:
     rhs: _Expr
 
 @final
-class Delete:
+class Change:
+    change: _Change
     sym: str
     args: list[_Expr]
-    def __init__(self, sym: str, args: list[_Expr]) -> None: ...
+    def __init__(self, change: _Change, sym: str, args: list[_Expr]) -> None: ...
 
 @final
 class Union:
@@ -195,7 +212,7 @@ class Extract:
     expr: _Expr
     variants: _Expr
 
-_Action: TypeAlias = Let | Set | Delete | Union | Panic | Expr_ | Extract
+_Action: TypeAlias = Let | Set | Change | Union | Panic | Expr_ | Extract
 
 ##
 # Other Structs
@@ -210,6 +227,7 @@ class FunctionDecl:
     merge_action: list[_Action]
     cost: int | None
     unextractable: bool
+    ignore_viz: bool
 
     def __init__(
         self,
@@ -220,6 +238,7 @@ class FunctionDecl:
         merge_action: list[_Action] = [],  # noqa: B006
         cost: int | None = None,
         unextractable: bool = False,
+        ignore_viz: bool = False,
     ) -> None: ...
 
 @final
@@ -374,7 +393,8 @@ class RewriteCommand:
     # TODO: Rename to ruleset
     name: str
     rewrite: Rewrite
-    def __init__(self, name: str, rewrite: Rewrite) -> None: ...
+    subsume: bool
+    def __init__(self, name: str, rewrite: Rewrite, subsume: bool) -> None: ...
 
 @final
 class BiRewriteCommand:

egglog/builtins.py

@@ -7,8 +7,8 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Generic, Protocol, TypeAlias, TypeVar, Union
 
+from .conversion import converter
 from .egraph import Expr, Unit, function, method
-from .runtime import converter
 
 if TYPE_CHECKING:
     from collections.abc import Callable

egglog/conversion.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, TypeVar, cast
+
+from .declarations import *
+from .pretty import *
+from .runtime import *
+from .thunk import *
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from .declarations import HasDeclerations
+    from .egraph import Expr
+
+__all__ = ["convert", "converter", "resolve_literal", "convert_to_same_type"]
+# Mapping from (source type, target type) to and function which takes in the runtimes values of the source and return the target
+CONVERSIONS: dict[tuple[type | JustTypeRef, JustTypeRef], tuple[int, Callable]] = {}
+# Global declerations to store all convertable types so we can query if they have certain methods or not
+# Defer it as a thunk so we can register conversions without triggering type signature loading
+CONVERSIONS_DECLS: Callable[[], Declarations] = Thunk.value(Declarations())
+
+T = TypeVar("T")
+V = TypeVar("V", bound="Expr")
+
+
+class ConvertError(Exception):
+    pass
+
+
+def converter(from_type: type[T], to_type: type[V], fn: Callable[[T], V], cost: int = 1) -> None:
+    """
+    Register a converter from some type to an egglog type.
+    """
+    to_type_name = process_tp(to_type)
+    if not isinstance(to_type_name, JustTypeRef):
+        raise TypeError(f"Expected return type to be a egglog type, got {to_type_name}")
+    _register_converter(process_tp(from_type), to_type_name, fn, cost)
+
+
+def _register_converter(a: type | JustTypeRef, b: JustTypeRef, a_b: Callable, cost: int) -> None:
+    """
+    Registers a converter from some type to an egglog type, if not already registered.
+
+    Also adds transitive converters, i.e. if registering A->B and there is already B->C, then A->C will be registered.
+    Also, if registering A->B and there is already D->A, then D->B will be registered.
+    """
+    if a == b:
+        return
+    if (a, b) in CONVERSIONS and CONVERSIONS[(a, b)][0] <= cost:
+        return
+    CONVERSIONS[(a, b)] = (cost, a_b)
+    for (c, d), (other_cost, c_d) in list(CONVERSIONS.items()):
+        if b == c:
+            _register_converter(a, d, _ComposedConverter(a_b, c_d), cost + other_cost)
+        if a == d:
+            _register_converter(c, b, _ComposedConverter(c_d, a_b), cost + other_cost)
+
+
+@dataclass
+class _ComposedConverter:
+    """
+    A converter which is composed of multiple converters.
+
+    _ComposeConverter(a_b, b_c) is equivalent to lambda x: b_c(a_b(x))
+
+    We use the dataclass instead of the lambda to make it easier to debug.
+    """
+
+    a_b: Callable
+    b_c: Callable
+
+    def __call__(self, x: object) -> object:
+        return self.b_c(self.a_b(x))
+
+    def __str__(self) -> str:
+        return f"{self.b_c} ∘ {self.a_b}"
+
+
+def convert(source: object, target: type[V]) -> V:
+    """
+    Convert a source object to a target type.
+    """
+    assert isinstance(target, RuntimeClass)
+    return cast(V, resolve_literal(target.__egg_tp__, source))
+
+
+def convert_to_same_type(source: object, target: RuntimeExpr) -> RuntimeExpr:
+    """
+    Convert a source object to the same type as the target.
+    """
+    tp = target.__egg_typed_expr__.tp
+    return resolve_literal(tp.to_var(), source)
+
+
+def process_tp(tp: type | RuntimeClass) -> JustTypeRef | type:
+    """
+    Process a type before converting it, to add it to the global declerations and resolve to a ref.
+    """
+    global CONVERSIONS_DECLS
+    if isinstance(tp, RuntimeClass):
+        CONVERSIONS_DECLS = Thunk.fn(_combine_decls, CONVERSIONS_DECLS, tp)
+        return tp.__egg_tp__.to_just()
+    return tp
+
+
+def _combine_decls(d: Callable[[], Declarations], x: HasDeclerations) -> Declarations:
+    return Declarations.create(d(), x)
+
+
+def min_convertable_tp(a: object, b: object, name: str) -> JustTypeRef:
+    """
+    Returns the minimum convertable type between a and b, that has a method `name`, raising a ConvertError if no such type exists.
+    """
+    decls = CONVERSIONS_DECLS()
+    a_tp = _get_tp(a)
+    b_tp = _get_tp(b)
+    a_converts_to = {
+        to: c for ((from_, to), (c, _)) in CONVERSIONS.items() if from_ == a_tp and decls.has_method(to.name, name)
+    }
+    b_converts_to = {
+        to: c for ((from_, to), (c, _)) in CONVERSIONS.items() if from_ == b_tp and decls.has_method(to.name, name)
+    }
+    if isinstance(a_tp, JustTypeRef):
+        a_converts_to[a_tp] = 0
+    if isinstance(b_tp, JustTypeRef):
+        b_converts_to[b_tp] = 0
+    common = set(a_converts_to) & set(b_converts_to)
+    if not common:
+        raise ConvertError(f"Cannot convert {a_tp} and {b_tp} to a common type")
+    return min(common, key=lambda tp: a_converts_to[tp] + b_converts_to[tp])
+
+
+def identity(x: object) -> object:
+    return x
+
+
+def resolve_literal(tp: TypeOrVarRef, arg: object) -> RuntimeExpr:
+    arg_type = _get_tp(arg)
+
+    # If we have any type variables, dont bother trying to resolve the literal, just return the arg
+    try:
+        tp_just = tp.to_just()
+    except NotImplementedError:
+        # If this is a var, it has to be a runtime exprssions
+        assert isinstance(arg, RuntimeExpr)
+        return arg
+    if arg_type == tp_just:
+        # If the type is an egg type, it has to be a runtime expr
+        assert isinstance(arg, RuntimeExpr)
+        return arg
+    # Try all parent types as well, if we are converting from a Python type
+    for arg_type_instance in arg_type.__mro__ if isinstance(arg_type, type) else [arg_type]:
+        try:
+            fn = CONVERSIONS[(cast(JustTypeRef | type, arg_type_instance), tp_just)][1]
+        except KeyError:
+            continue
+        break
+    else:
+        raise ConvertError(f"Cannot convert {arg_type} to {tp_just}")
+    return fn(arg)
+
+
+def _get_tp(x: object) -> JustTypeRef | type:
+    if isinstance(x, RuntimeExpr):
+        return x.__egg_typed_expr__.tp
+    tp = type(x)
+    # If this value has a custom metaclass, let's use that as our index instead of the type
+    if type(tp) != type:
+        return type(tp)
+    return tp