egglog 10.0.1__cp312-cp312-win_amd64.whl → 10.0.2__cp312-cp312-win_amd64.whl

egglog/builtins.py

@@ -9,7 +9,7 @@ from collections.abc import Callable
 from fractions import Fraction
 from functools import partial, reduce
 from types import FunctionType, MethodType
-from typing import TYPE_CHECKING, Generic, Protocol, TypeAlias, TypeVar, Union, cast, overload
+from typing import TYPE_CHECKING, Generic, Protocol, TypeAlias, TypeVar, cast, overload
 
 from typing_extensions import TypeVarTuple, Unpack
 
@@ -101,8 +101,6 @@ def join(*strings: StringLike) -> String: ...
 
 converter(str, String, String)
 
-BoolLike: TypeAlias = Union["Bool", bool]
-
 
 class Bool(BuiltinExpr, egg_sort="bool"):
     @method(preserve=True)
@@ -133,10 +131,10 @@ class Bool(BuiltinExpr, egg_sort="bool"):
     def implies(self, other: BoolLike) -> Bool: ...
 
 
-converter(bool, Bool, Bool)
+BoolLike: TypeAlias = Bool | bool
 
-# The types which can be convertered into an i64
-i64Like: TypeAlias = Union["i64", int]  # noqa: N816, PYI042
+
+converter(bool, Bool, Bool)
 
 
 class i64(BuiltinExpr):  # noqa: N801
@@ -248,6 +246,9 @@ class i64(BuiltinExpr):  # noqa: N801
     def bool_ge(self, other: i64Like) -> Bool: ...
 
 
+# The types which can be convertered into an i64
+i64Like: TypeAlias = i64 | int  # noqa: N816, PYI042
+
 converter(int, i64, i64)
 
 
@@ -255,9 +256,6 @@ converter(int, i64, i64)
 def count_matches(s: StringLike, pattern: StringLike) -> i64: ...
 
 
-f64Like: TypeAlias = Union["f64", float]  # noqa: N816, PYI042
-
-
 class f64(BuiltinExpr):  # noqa: N801
     @method(preserve=True)
     def eval(self) -> float:
@@ -337,6 +335,9 @@ class f64(BuiltinExpr):  # noqa: N801
     def to_string(self) -> String: ...
 
 
+f64Like: TypeAlias = f64 | float  # noqa: N816, PYI042
+
+
 converter(float, f64, f64)
 
 

egglog/declarations.py

@@ -93,7 +93,7 @@ class DelayedDeclerations:
         # Catch attribute error, so that it isn't bubbled up as a missing attribute and fallbacks on `__getattr__`
         # instead raise explicitly
         except AttributeError as err:
-            msg = f"Cannot resolve declerations for {self}"
+            msg = f"Cannot resolve declarations for {self}"
             raise RuntimeError(msg) from err
 
 
@@ -308,11 +308,11 @@ class ClassTypeVarRef:
     module: str
 
     def to_just(self) -> JustTypeRef:
-        msg = "egglog does not support generic classes yet."
+        msg = f"{self}: egglog does not support generic classes yet."
         raise NotImplementedError(msg)
 
     def __str__(self) -> str:
-        return f"{self.module}.{self.name}"
+        return str(self.to_type_var())
 
     @classmethod
     def from_type_var(cls, typevar: TypeVar) -> ClassTypeVarRef:

egglog/egraph.py

@@ -16,7 +16,6 @@ from typing import (
     ClassVar,
     Generic,
     Literal,
-    Never,
     TypeAlias,
     TypedDict,
     TypeVar,
@@ -26,7 +25,7 @@ from typing import (
 )
 
 import graphviz
-from typing_extensions import ParamSpec, Self, Unpack, assert_never
+from typing_extensions import Never, ParamSpec, Self, Unpack, assert_never
 
 from . import bindings
 from .conversion import *
@@ -36,6 +35,7 @@ from .ipython_magic import IN_IPYTHON
 from .pretty import pretty_decl
 from .runtime import *
 from .thunk import *
+from .version_compat import *
 
 if TYPE_CHECKING:
     from .builtins import String, Unit
@@ -169,8 +169,9 @@ def check_eq(x: BASE_EXPR, y: BASE_EXPR, schedule: Schedule | None = None, *, ad
     except bindings.EggSmolError as err:
         if display:
             egraph.display()
-        err.add_note(f"Failed:\n{eq(x).to(y)}\n\nExtracted:\n {eq(egraph.extract(x)).to(egraph.extract(y))})")
-        raise
+        raise add_note(
+            f"Failed:\n{eq(x).to(y)}\n\nExtracted:\n {eq(egraph.extract(x)).to(egraph.extract(y))})", err
+        ) from None
     return egraph
 
 
@@ -492,8 +493,7 @@ def _generate_class_decls(  # noqa: C901,PLR0912
                 reverse_args=reverse_args,
             )
         except Exception as e:
-            e.add_note(f"Error processing {cls_name}.{method_name}")
-            raise
+            raise add_note(f"Error processing {cls_name}.{method_name}", e) from None
 
         if not builtin and not isinstance(ref, InitRef) and not mutates:
             add_default_funcs.append(add_rewrite)
@@ -569,16 +569,11 @@ def _fn_decl(
     if not isinstance(fn, FunctionType):
         raise NotImplementedError(f"Can only generate function decls for functions not {fn}  {type(fn)}")
 
-    hint_globals = fn.__globals__.copy()
-    # Copy Callable into global if not present bc sometimes it gets automatically removed by ruff to type only block
-    # https://docs.astral.sh/ruff/rules/typing-only-standard-library-import/
-    if "Callable" not in hint_globals:
-        hint_globals["Callable"] = Callable
     # Instead of passing both globals and locals, just pass the globals. Otherwise, for some reason forward references
     # won't be resolved correctly
     # We need this to be false so it returns "__forward_value__" https://github.com/python/cpython/blob/440ed18e08887b958ad50db1b823e692a747b671/Lib/typing.py#L919
     # https://github.com/egraphs-good/egglog-python/issues/210
-    hint_globals.update(hint_locals)
+    hint_globals = {**fn.__globals__, **hint_locals}
     hints = get_type_hints(fn, hint_globals)
 
     params = list(signature(fn).parameters.values())
@@ -632,7 +627,7 @@ def _fn_decl(
     )
     decls |= merged
 
-    # defer this in generator so it doesnt resolve for builtins eagerly
+    # defer this in generator so it doesn't resolve for builtins eagerly
     args = (TypedExprDecl(tp.to_just(), VarDecl(name, False)) for name, tp in zip(arg_names, arg_types, strict=True))
     res_ref: FunctionRef | MethodRef | ClassMethodRef | PropertyRef | InitRef | UnnamedFunctionRef
     res_thunk: Callable[[], object]
@@ -676,7 +671,7 @@ def _fn_decl(
             )
         res_ref = ref
         decls.set_function_decl(ref, decl)
-        res_thunk = Thunk.fn(_create_default_value, decls, ref, fn, args, ruleset)
+        res_thunk = Thunk.fn(_create_default_value, decls, ref, fn, args, ruleset, context=f"creating {ref}")
     return res_ref, Thunk.fn(_add_default_rewrite_function, decls, res_ref, return_type, ruleset, res_thunk, subsume)
 
 
@@ -1045,8 +1040,7 @@ class EGraph:
                 bindings.ActionCommand(bindings.Extract(span(2), expr, bindings.Lit(span(2), bindings.Int(n))))
             )
         except BaseException as e:
-            e.add_note("Extracting: " + str(expr))
-            raise
+            raise add_note("Extracting: " + str(expr), e)  # noqa: B904
         extract_report = self._egraph.extract_report()
         if not extract_report:
             msg = "No extract report saved"

egglog/exp/array_api.py

@@ -69,6 +69,7 @@ import numpy as np
 
 from egglog import *
 from egglog.runtime import RuntimeExpr
+from egglog.version_compat import add_note
 
 from .program_gen import *
 
@@ -1198,13 +1199,13 @@ class NDArray(Expr, ruleset=array_api_ruleset):
 
 NDArrayLike: TypeAlias = NDArray | ValueLike | TupleValueLike
 
-converter(NDArray, IndexKey, IndexKey.ndarray)
-converter(Value, NDArray, NDArray.scalar)
+converter(NDArray, IndexKey, lambda v: IndexKey.ndarray(v))
+converter(Value, NDArray, lambda v: NDArray.scalar(v))
 # Need this if we want to use ints in slices of arrays coming from 1d arrays, but make it more expensive
 # to prefer upcasting in the other direction when we can, which is safer at runtime
 converter(NDArray, Value, lambda n: n.to_value(), 100)
-converter(TupleValue, NDArray, NDArray.vector)
-converter(TupleInt, TupleValue, TupleValue.from_tuple_int)
+converter(TupleValue, NDArray, lambda v: NDArray.vector(v))
+converter(TupleInt, TupleValue, lambda v: TupleValue.from_tuple_int(v))
 
 
 @array_api_ruleset.register
@@ -1383,8 +1384,8 @@ class IntOrTuple(Expr, ruleset=array_api_ruleset):
     def tuple(cls, value: TupleIntLike) -> IntOrTuple: ...
 
 
-converter(Int, IntOrTuple, IntOrTuple.int)
-converter(TupleInt, IntOrTuple, IntOrTuple.tuple)
+converter(Int, IntOrTuple, lambda v: IntOrTuple.int(v))
+converter(TupleInt, IntOrTuple, lambda v: IntOrTuple.tuple(v))
 
 
 class OptionalIntOrTuple(Expr, ruleset=array_api_ruleset):
@@ -1395,7 +1396,7 @@ class OptionalIntOrTuple(Expr, ruleset=array_api_ruleset):
 
 
 converter(type(None), OptionalIntOrTuple, lambda _: OptionalIntOrTuple.none)
-converter(IntOrTuple, OptionalIntOrTuple, OptionalIntOrTuple.some)
+converter(IntOrTuple, OptionalIntOrTuple, lambda v: OptionalIntOrTuple.some(v))
 
 
 @function
@@ -1980,6 +1981,5 @@ def try_evaling(egraph: EGraph, schedule: Schedule, expr: Expr, prim_expr: Built
             extracted = egraph.extract(prim_expr)
         except BaseException as e:
             # egraph.display(n_inline_leaves=1, split_primitive_outputs=True)
-            e.add_note(f"Cannot evaluate {egraph.extract(expr)}")
-            raise
+            raise add_note(f"Cannot evaluate {egraph.extract(expr)}", e)  # noqa: B904
     return extracted.eval()  # type: ignore[attr-defined]

egglog/exp/program_gen.py

@@ -5,12 +5,10 @@ Builds up imperative string expressions from a functional expression.
 
 from __future__ import annotations
 
-from typing import TypeAlias, Union
+from typing import TypeAlias
 
 from egglog import *
 
-ProgramLike: TypeAlias = Union["Program", StringLike]
-
 
 class Program(Expr):
     """
@@ -97,6 +95,9 @@ class Program(Expr):
         """
 
 
+ProgramLike: TypeAlias = Program | StringLike
+
+
 converter(String, Program, Program)
 
 

egglog/runtime.py

@@ -22,6 +22,7 @@ from .declarations import *
 from .pretty import *
 from .thunk import Thunk
 from .type_constraint_solver import *
+from .version_compat import *
 
 if TYPE_CHECKING:
     from collections.abc import Iterable
@@ -249,8 +250,7 @@ class RuntimeClass(DelayedDeclerations):
         try:
             cls_decl = self.__egg_decls__._classes[self.__egg_tp__.name]
         except Exception as e:
-            e.add_note(f"Error processing class {self.__egg_tp__.name}")
-            raise
+            raise add_note(f"Error processing class {self.__egg_tp__.name}", e) from None
 
         preserved_methods = cls_decl.preserved_methods
         if name in preserved_methods:
@@ -281,6 +281,9 @@ class RuntimeClass(DelayedDeclerations):
     def __str__(self) -> str:
         return str(self.__egg_tp__)
 
+    def __repr__(self) -> str:
+        return str(self)
+
     # Make hashable so can go in Union
     def __hash__(self) -> int:
         return hash((id(self.__egg_decls_thunk__), self.__egg_tp__))
@@ -315,8 +318,7 @@ class RuntimeFunction(DelayedDeclerations):
         try:
             signature = self.__egg_decls__.get_callable_decl(self.__egg_ref__).signature
         except Exception as e:
-            e.add_note(f"Failed to find callable {self}")
-            raise
+            raise add_note(f"Failed to find callable {self}", e)  # noqa: B904
         decls = self.__egg_decls__.copy()
         # Special case function application bc we dont support variadic generics yet generally
         if signature == "fn-app":

egglog/thunk.py

@@ -41,13 +41,13 @@ class Thunk(Generic[T, Unpack[TS]]):
     state: Resolved[T] | Unresolved[T, Unpack[TS]] | Resolving | Error
 
     @classmethod
-    def fn(cls, fn: Callable[[Unpack[TS]], T], *args: Unpack[TS]) -> Thunk[T, Unpack[TS]]:
+    def fn(cls, fn: Callable[[Unpack[TS]], T], *args: Unpack[TS], context: str | None = None) -> Thunk[T, Unpack[TS]]:
         """
         Create a thunk based on some functions and some partial args.
 
         If the function is called while it is being resolved recursively it will raise an exception.
         """
-        return cls(Unresolved(fn, args))
+        return cls(Unresolved(fn, args, context))
 
     @classmethod
     def value(cls, value: T) -> Thunk[T]:
@@ -57,12 +57,12 @@ class Thunk(Generic[T, Unpack[TS]]):
         match self.state:
             case Resolved(value):
                 return value
-            case Unresolved(fn, args):
+            case Unresolved(fn, args, context):
                 self.state = Resolving()
                 try:
                     res = fn(*args)
                 except Exception as e:
-                    self.state = Error(e)
+                    self.state = Error(e, context)
                     raise e from None
                 else:
                     self.state = Resolved(res)
@@ -83,6 +83,7 @@ class Resolved(Generic[T]):
 class Unresolved(Generic[T, Unpack[TS]]):
     fn: Callable[[Unpack[TS]], T]
     args: tuple[Unpack[TS]]
+    context: str | None
 
 
 @dataclass
@@ -93,3 +94,4 @@ class Resolving:
 @dataclass
 class Error:
     e: Exception
+    context: str | None

egglog/type_constraint_solver.py

@@ -107,7 +107,7 @@ class TypeConstraintSolver:
                 try:
                     return self._cls_typevar_index_to_type[cls_name][tp]
                 except KeyError as e:
-                    raise TypeConstraintError(f"Not enough bound typevars for {tp} in class {cls_name}") from e
+                    raise TypeConstraintError(f"Not enough bound typevars for {tp!r} in class {cls_name}") from e
             case TypeRefWithVars(name, args):
                 return JustTypeRef(name, tuple(self.substitute_typevars(arg, cls_name) for arg in args))
         assert_never(tp)

egglog/version_compat.py

@@ -0,0 +1,87 @@
+import collections
+import sys
+import types
+import typing
+
+BEFORE_3_11 = sys.version_info < (3, 11)
+
+__all__ = ["add_note"]
+
+
+def add_note(message: str, exc: BaseException) -> BaseException:
+    """
+    Backwards compatible add_note for Python <= 3.10
+    """
+    if BEFORE_3_11:
+        return exc
+    exc.add_note(message)
+    return exc
+
+
+# For Python version 3.10 need to monkeypatch this function so that RuntimeClass type parameters
+# will be collected as typevars
+if BEFORE_3_11:
+
+    @typing.no_type_check
+    def _collect_type_vars_monkeypatch(types_, typevar_types=None):
+        """
+        Collect all type variable contained
+        in types in order of first appearance (lexicographic order). For example::
+
+            _collect_type_vars((T, List[S, T])) == (T, S)
+        """
+        from .runtime import RuntimeClass
+
+        if typevar_types is None:
+            typevar_types = typing.TypeVar
+        tvars = []
+        for t in types_:
+            if isinstance(t, typevar_types) and t not in tvars:
+                tvars.append(t)
+            # **MONKEYPATCH CHANGE HERE TO ADD RuntimeClass**
+            if isinstance(t, (typing._GenericAlias, typing.GenericAlias, types.UnionType, RuntimeClass)):  # type: ignore[name-defined]
+                tvars.extend([t for t in t.__parameters__ if t not in tvars])
+        return tuple(tvars)
+
+    typing._collect_type_vars = _collect_type_vars_monkeypatch  # type: ignore[attr-defined]
+
+    @typing.no_type_check
+    @typing._tp_cache
+    def __getitem__monkeypatch(self, params):  # noqa: C901, PLR0912
+        from .runtime import RuntimeClass
+
+        if self.__origin__ in (typing.Generic, typing.Protocol):
+            # Can't subscript Generic[...] or Protocol[...].
+            raise TypeError(f"Cannot subscript already-subscripted {self}")
+        if not isinstance(params, tuple):
+            params = (params,)
+        params = tuple(typing._type_convert(p) for p in params)
+        if self._paramspec_tvars and any(isinstance(t, typing.ParamSpec) for t in self.__parameters__):
+            params = typing._prepare_paramspec_params(self, params)
+        else:
+            typing._check_generic(self, params, len(self.__parameters__))
+
+        subst = dict(zip(self.__parameters__, params, strict=False))
+        new_args = []
+        for arg in self.__args__:
+            if isinstance(arg, self._typevar_types):
+                if isinstance(arg, typing.ParamSpec):
+                    arg = subst[arg]  # noqa: PLW2901
+                    if not typing._is_param_expr(arg):
+                        raise TypeError(f"Expected a list of types, an ellipsis, ParamSpec, or Concatenate. Got {arg}")
+                else:
+                    arg = subst[arg]  # noqa: PLW2901
+            # **MONKEYPATCH CHANGE HERE TO ADD RuntimeClass**
+            elif isinstance(arg, (typing._GenericAlias, typing.GenericAlias, types.UnionType, RuntimeClass)):
+                subparams = arg.__parameters__
+                if subparams:
+                    subargs = tuple(subst[x] for x in subparams)
+                    arg = arg[subargs]  # noqa: PLW2901
+            # Required to flatten out the args for CallableGenericAlias
+            if self.__origin__ == collections.abc.Callable and isinstance(arg, tuple):
+                new_args.extend(arg)
+            else:
+                new_args.append(arg)
+        return self.copy_with(tuple(new_args))
+
+    typing._GenericAlias.__getitem__ = __getitem__monkeypatch  # type: ignore[attr-defined]

{egglog-10.0.1.dist-info → egglog-10.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: egglog
-Version: 10.0.1
+Version: 10.0.2
 Classifier: Environment :: MacOS X
 Classifier: Environment :: Win32 (MS Windows)
 Classifier: Intended Audience :: Developers

{egglog-10.0.1.dist-info → egglog-10.0.2.dist-info}/RECORD

@@ -1,13 +1,17 @@
-egglog-10.0.1.dist-info/METADATA,sha256=aV4v_MVLJxVZ6W0NUmSopQcAA9kulEpBgG2aLGJQn3M,4019
-egglog-10.0.1.dist-info/WHEEL,sha256=jABKVkLC9kJr8mi_er5jOqpiQUjARSLXDUIIxDqsS50,96
-egglog-10.0.1.dist-info/licenses/LICENSE,sha256=TfaboMVZ81Q6OUaKjU7z6uVjSlcGKclLYcOpgDbm9_s,1091
+egglog-10.0.2.dist-info/METADATA,sha256=xR0HB5r6onjZhIk878L992umIt2QZT3zzRRCEN1NkF0,4019
+egglog-10.0.2.dist-info/WHEEL,sha256=2Rq0eWWH7u9Ffm_ZQEcE2_DVE8if9XSfMophnE-xWmc,96
+egglog-10.0.2.dist-info/licenses/LICENSE,sha256=TfaboMVZ81Q6OUaKjU7z6uVjSlcGKclLYcOpgDbm9_s,1091
+egglog/__init__.py,sha256=TZ3IMVKoz5Qr97VFe-YT7oyT2NACikTis21PpVlSCmg,326
+egglog/bindings.cp312-win_amd64.pyd,sha256=5QoF0a8dXYh-usqUNV2SKAETYdFE8ItjyO-wP1-xxP0,4541952
 egglog/bindings.pyi,sha256=fnRiGyHuM-m0fDe91kFryUC09U87f5XXPiY6Lno8bvk,14497
-egglog/builtins.py,sha256=7T66DZ2fd0rxApVq6vrvHwoLTTXrGy1TIUjBM5SrfD0,30720
+egglog/builtins.py,sha256=su57iYmxpWNt14S9Dw1CgBfSBUYiTLCS6h1ksShZUMk,30691
 egglog/config.py,sha256=mALVaxh7zmGrbuyzaVKVmYKcu1lF703QsKJw8AF7gSM,176
 egglog/conversion.py,sha256=o6iE32taKz-PBX8aDo5i4jGELdEai-wrzMEZUC1lqsU,10257
-egglog/declarations.py,sha256=R4U8JhM6ChOMmPEgG6tL2sJ8wJGsIEEVVN5lVY-6k2w,23011
-egglog/egraph.py,sha256=Cdf51_7oHGq7Fg5mLizc7YkRfXZgR8kocfSOQMFtEK0,64724
+egglog/declarations.py,sha256=7tT7RXHEKVoZtm14hT-Va_1jKuwOMPGFWg8VdRYhT88,23015
+egglog/egraph.py,sha256=BnLyNXJ6UqMIM2gqYBgeMXvqjbX5OAwnMTRudOUyxtU,64497
 egglog/egraph_state.py,sha256=wkuHoXmEzcUFspvNl8ZG7_xS1J7XZTK3RPnlZEuvk9k,28720
+egglog/examples/README.rst,sha256=QrbfmivODBvUvmY3-dHarcbC6bEvwoqAfTDhiI-aJxU,237
+egglog/examples/__init__.py,sha256=KuhaJFOyz_rpUvEqZubsgLnv6rhQNE_AVFXA6bUnpdY,34
 egglog/examples/bignum.py,sha256=r4UeVwpKK2iSZiT5MK4qqTWhWu76CAtSJ5YGDboO9tk,568
 egglog/examples/bool.py,sha256=pWZTjfXR1cFy3KcihLBU5AF5rn83ImORlhUUJ1YiAXc,733
 egglog/examples/eqsat_basic.py,sha256=ivYHFD52sjYyl5rWQ60ScxmvcbABYUBlPobDMu6HvN4,913
@@ -17,28 +21,25 @@ egglog/examples/lambda_.py,sha256=y0HrgtmF2Ml2h2crRvqd1fYRtJGPP_n91o-fiWfyCLM,84
 egglog/examples/matrix.py,sha256=_zmjgfFr2O_LjTcsTD-45_38Y_M1sP3AV39K6oFxAdw,5136
 egglog/examples/multiset.py,sha256=kSUFiN4qs8WXvexPCecqk3o5DzdywXacDmIiC5IDKCM,1507
 egglog/examples/ndarrays.py,sha256=T-wwef-n-3LDSjaO35zA8AZH5DXFFqq0XBSCQKEXV6E,4186
-egglog/examples/README.rst,sha256=QrbfmivODBvUvmY3-dHarcbC6bEvwoqAfTDhiI-aJxU,237
 egglog/examples/resolution.py,sha256=sKkbRI_v9XkQM0DriacKLINqKKDqYGFhvMCAS9tZbTA,2203
 egglog/examples/schedule_demo.py,sha256=iJtIbcLaZ7zK8UalY0z7KAKMqYjQx0MKTsNF24lKtik,652
-egglog/examples/__init__.py,sha256=KuhaJFOyz_rpUvEqZubsgLnv6rhQNE_AVFXA6bUnpdY,34
-egglog/exp/array_api.py,sha256=fNC4DRg19vo9-bQfkgAK-OrMml2pgf1rUh_ZPOT47JU,65691
+egglog/exp/__init__.py,sha256=G9zeKUcPBgIhgUg1meC86OfZVFETYIugyHWseTcCe_0,52
+egglog/exp/array_api.py,sha256=0bqgi2nigiW5uLEa35JBOh9hFM5-oRMGYpoknzS60Jw,65828
 egglog/exp/array_api_jit.py,sha256=c0lN-411M9LmEz8uM0ELXTtfUPMJDZFmy81-x3ck6PY,1591
 egglog/exp/array_api_loopnest.py,sha256=1KZ8kWtv00TVCbzqzWG92vz8Y1pBlPOLRIrJfxyDs9s,2518
 egglog/exp/array_api_numba.py,sha256=g0Yb7auB2MtJHgSzn7iVnsxn6ffL4FHggKvbEuuDwZs,2765
 egglog/exp/array_api_program_gen.py,sha256=qXaaW_Koz4P-KmQcyRHY1NDLCJL3O7NnE6iq2NX4yZU,22252
-egglog/exp/program_gen.py,sha256=XqL9e-TWcpDkkrSvrjO4cT7GI1br--KKkeK1B87Ivzw,13451
+egglog/exp/program_gen.py,sha256=obqPocwY9LpmXyjIRtONvafkJm84HKWDsR_fME0gns4,13438
 egglog/exp/siu_examples.py,sha256=nPV1IaA2NfIczpJPg3l8diUhoyio02KQUu-O55Pj1EQ,751
-egglog/exp/__init__.py,sha256=G9zeKUcPBgIhgUg1meC86OfZVFETYIugyHWseTcCe_0,52
 egglog/functionalize.py,sha256=7yBi5rlYS56lP4Fz_2REyOyj56Tag5R80bXkUXfj5pk,3938
 egglog/ipython_magic.py,sha256=QDw45CA2wKi9vrBbvHZXLeMaRtoHSGLBJdqyNFtvD7o,1230
 egglog/pretty.py,sha256=8ErTOWGHDY96W5B1ekctKNwRm0fqPHUrqLlX-h1fSJM,20986
 egglog/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-egglog/runtime.py,sha256=4bDRE2iK51mOHCRAfxYSbYegVP54ZPAda5zEf0KCczw,26374
-egglog/thunk.py,sha256=t71q_SIRSpYh6oqOQ-TEDqMByrrwp5xvSJbVy3XONbQ,2263
-egglog/type_constraint_solver.py,sha256=kSJf8S1CxkicpPy_B2cNP9XiTf-d4TQNd7_IwfG-_-k,4629
+egglog/runtime.py,sha256=zxcgUR5N_-qHs12vcH4r0oANY-9ra16jwlCAsNxZyC4,26465
+egglog/thunk.py,sha256=97JH5VVrr5m3yaua40StfDsQYEvACXirBzZv9CHHLbY,2368
+egglog/type_constraint_solver.py,sha256=uRLho3KQUtMn3ncugXADN5SfNqmqekduOl5CuWhhx4M,4631
+egglog/version_compat.py,sha256=axYHagkkErdrW1aW6OyWyHUqjpdKNZQ9N4U1KpL4x3s,3595
 egglog/visualizer.css,sha256=DDmxZfLmFygwVkQwel0gGUiM5BZqgunawWeSfaRYBr8,259399
 egglog/visualizer.js,sha256=kDkYzE5cLLhmpNaWqSfQWzD0SlSsNe9KzT_GpNqhWgo,3789092
 egglog/visualizer_widget.py,sha256=TGkf61P_f4EvCFcyqwQC_8XYUkujFhcQnEG9vHWLPC4,1358
-egglog/__init__.py,sha256=TZ3IMVKoz5Qr97VFe-YT7oyT2NACikTis21PpVlSCmg,326
-egglog/bindings.cp312-win_amd64.pyd,sha256=OTvTd_Yv3rdKWnHI2hrgpBylG0pkzT-w1dsoJ3jUz8Q,4543488
-egglog-10.0.1.dist-info/RECORD,,
+egglog-10.0.2.dist-info/RECORD,,

{egglog-10.0.1.dist-info → egglog-10.0.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: maturin (1.8.3)
+Generator: maturin (1.8.7)
 Root-Is-Purelib: false
 Tag: cp312-cp312-win_amd64