egglog 7.1.0__tar.gz → 7.2.0__tar.gz

{egglog-7.1.0 → egglog-7.2.0}/.github/workflows/version.yml

@@ -128,7 +128,7 @@ jobs:
       - run: |
           git tag "v$VERSION"
           git push --tags
-          gh pr merge --admin --delete-branch
+          gh pr merge --admin --delete-branch --merge
         env:
           VERSION: ${{ needs.bump.outputs.version }}
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

{egglog-7.1.0 → egglog-7.2.0}/Cargo.lock

@@ -312,7 +312,7 @@ dependencies = [
 
 [[package]]
 name = "egglog-python"
-version = "7.1.0"
+version = "7.2.0"
 dependencies = [
  "egglog",
  "egraph-serialize",

{egglog-7.1.0 → egglog-7.2.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "egglog-python"
-version = "7.1.0"
+version = "7.2.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

{egglog-7.1.0 → egglog-7.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: egglog
-Version: 7.1.0
+Version: 7.2.0
 Classifier: Environment :: MacOS X
 Classifier: Environment :: Win32 (MS Windows)
 Classifier: Intended Audience :: Developers
@@ -30,6 +30,11 @@ Requires-Dist: scikit-learn; extra == 'array'
 Requires-Dist: array_api_compat; extra == 'array'
 Requires-Dist: numba==0.59.1; extra == 'array'
 Requires-Dist: llvmlite==0.42.0; extra == 'array'
+Requires-Dist: pre-commit; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: anywidget[dev]; extra == 'dev'
+Requires-Dist: egglog[docs,test]; extra == 'dev'
 Requires-Dist: pydata-sphinx-theme; extra == 'docs'
 Requires-Dist: myst-nb; extra == 'docs'
 Requires-Dist: sphinx-autodoc-typehints; extra == 'docs'
@@ -42,15 +47,10 @@ Requires-Dist: egglog[array]; extra == 'docs'
 Requires-Dist: line-profiler; extra == 'docs'
 Requires-Dist: sphinxcontrib-mermaid; extra == 'docs'
 Requires-Dist: ablog; extra == 'docs'
-Requires-Dist: pre-commit; extra == 'dev'
-Requires-Dist: ruff; extra == 'dev'
-Requires-Dist: mypy; extra == 'dev'
-Requires-Dist: anywidget[dev]; extra == 'dev'
-Requires-Dist: egglog[docs,test]; extra == 'dev'
 Provides-Extra: test
 Provides-Extra: array
-Provides-Extra: docs
 Provides-Extra: dev
+Provides-Extra: docs
 License-File: LICENSE
 Summary: e-graphs in Python built around the the egglog rust library
 License: MIT

{egglog-7.1.0 → egglog-7.2.0}/docs/changelog.md

@@ -4,6 +4,11 @@ _This project uses semantic versioning_
 
 ## UNRELEASED
 
+## 7.2.0 (2024-05-23)
+
+- Adds ability to use function bodies as default rewrites ([#167](https://github.com/egraphs-good/egglog-python/pull/167))
+- Fixed bug with creating empty maps and adding to maps ([#168](https://github.com/egraphs-good/egglog-python/pull/168))
+
 ## 7.1.0 (2024-05-03)
 
 ## New Feaatures

egglog-7.2.0/docs/reference/contributing.md

@@ -0,0 +1,91 @@
+# Contributing
+
+## Development
+
+This package is in active development and welcomes contributions!
+
+Feel free to bring up any questions/comments on [the Zulip chat](https://egraphs.zulipchat.com/) or open an issue.
+
+All feedback is welcome and encouraged, it's great to hear about anything that works well or could be improved.
+
+### Getting Started
+
+To get started locally developing with this project, fork it and clone it to your local machine.
+
+Using [the Github CLI](https://github.com/cli/cli#installation) this would be:
+
+```bash
+brew install gh
+gh repo fork egraphs-good/egglog-python --clone
+cd egglog-python
+```
+
+Then [install Rust](https://www.rust-lang.org/tools/install) and get a Python environment set up with a compatible version. Using [miniconda](https://formulae.brew.sh/cask/miniconda) this would be:
+
+```bash
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+brew install --cask miniconda
+conda create -n egglog-python python
+conda activate egglog-python
+```
+
+Then install the package in editable mode with the development dependencies:
+
+```bash
+pip install -e .[dev]
+```
+
+Anytime you change the rust code, you can run `pip install -e .` to recompile the rust code.
+
+### Running Tests
+
+To run the tests, you can use the `pytest` command:
+
+```bash
+pytest
+```
+
+All code must pass ruff linters and formaters. This will be checked automatically by the pre-commit if you run `pre-commit install`.
+
+To run it manually, you can use:
+
+```bash
+pre-commit run --all-files ruff
+```
+
+If you make changes to the rust bindings, you can check that the stub files accurately reflect the rust code by running:
+
+```bash
+pre-commit run --all-files --hook-stage manual stubtest
+```
+
+All code must all pass MyPy type checking. To run that locally use:
+
+```bash
+pre-commit run --all-files --hook-stage manual mypy
+```
+
+Finally, to build the docs locally and test that they work, you can run:
+
+```bash
+pre-commit run --all-files --hook-stage manual docs
+```
+
+## Making changes
+
+All changes that impact users should be documented in the `docs/changelog.md` file. Please also add tests for any new features
+or bug fixes.
+
+When you are ready to submit your changes, please open a pull request. The CI will run the tests and check the code style.
+
+## Documentation
+
+We use the [Diátaxis framework](https://diataxis.fr/) to organize our documentation. The "explanation" section has
+been renamed to "Blog" since most of the content there is more like a blog post than a reference manual. It uses
+the [ABlog](https://ablog.readthedocs.io/en/stable/index.html#how-it-works) extension.
+
+## Governance
+
+The governance is currently informal, with Saul Shanabrook as the lead maintainer. If the project grows and there
+are more contributors, we will formalize the governance structure in a way to allow it to be multi-stakeholder and
+to spread out the power and responsibility.

{egglog-7.1.0 → egglog-7.2.0}/docs/reference/python-integration.md

@@ -135,6 +135,7 @@ class Math(Expr):
     def var(cls, name: StringLike) -> Math: ...
 
     def __add__(self, other: Math) -> Math: ...
+    def __mul__(self, other: Math) -> Math: ...
 
 converter(i64, Math, Math)
 converter(String, Math, Math.var)
@@ -426,3 +427,86 @@ check_eq(added_two, MathList.EMPTY.append(Math(2) + Math(1)), math_list_ruleset.
 Note that this is all built on the [unstable function support added as a sort to egglog](https://github.com/egraphs-good/egglog/pull/348).
 While this sort is exposed directly at the high level with the `UnstableFn` class, we don't reccomend depending on it directly, and instead
 using the builtin Python type annotations. This will allow us to change the implementation in the future without breaking user code.
+
+## Default Replacements
+
+When defining a function or a constant, you can also provide a default replacement value. This is useful when
+you might want both the original value and the replaced value in the e-graph, so that later rules could reference either.
+
+```{code-cell} python
+@function
+def math_float(f: f64Like) -> Math:
+    ...
+
+
+# Can add a default replacement value for a constants
+pi = constant("pi", Math, math_float(3.14))
+
+
+# or for a function by providing a body
+@function
+def square(x: Math) -> Math:
+    return x * x
+
+# thse rewrites will be added to the e-graph under the default ruleset
+egraph = EGraph()
+egraph.register(pi)
+egraph.register(square(Math.var('x')))
+egraph.run(1)
+egraph.check(eq(pi).to(math_float(3.14)))
+egraph.check(eq(square(Math.var('x'))).to(Math.var('x') * Math.var('x')))
+egraph
+```
+
+This is equivalent to adding the rewrite rules to the e-graph directly, like this, but just more succinct:
+
+```python
+x  = var("x", Math)
+egraph.register(rewrite(pi).to(math_float(3.14)))
+egraph.register(rewrite(square(x)).to(x * x))
+```
+
+You can also specify a ruleset to add the rewrites to, by passing in the `ruleset` keyword argument:
+
+```{code-cell} python
+math_ruleset = ruleset()
+
+e_constant = constant("e", Math, math_float(2.71), ruleset=math_ruleset)
+
+@function(ruleset=math_ruleset)
+def cube(x: Math) -> Math:
+    return x * x * x
+
+
+egraph.register(e_constant)
+egraph.register(cube(Math.var('x')))
+egraph.run(math_ruleset)
+egraph.check(eq(e_constant).to(math_float(2.71)))
+egraph.check(eq(cube(Math.var('x'))).to(Math.var('x') * Math.var('x') * Math.var('x')))
+```
+
+### Default Replacement for Classes
+
+In classes, you can also provide a default replacement value for constants and methods, and an optional ruleset on the class constructor:
+
+```{code-cell} python
+other_math_ruleset = ruleset()
+
+
+class WrappedMath(Expr, ruleset=other_math_ruleset):
+    PI: ClassVar[Math] = math_float(3.14)
+
+    def __init__(self, x: Math) -> None: ...
+
+    def double(self) -> WrappedMath:
+        return self + self
+
+    def __add__(self, other: WrappedMath) -> WrappedMath: ...
+
+x = WrappedMath(WrappedMath.PI).double()
+egraph = EGraph()
+egraph.register(x)
+egraph.run(other_math_ruleset * 2)
+egraph.check(eq(x).to(WrappedMath(math_float(3.14)) + WrappedMath(math_float(3.14))))
+egraph
+```

{egglog-7.1.0 → egglog-7.2.0}/python/egglog/declarations.py

@@ -71,6 +71,8 @@ __all__ = [
     "CommandDecl",
     "SpecialFunctions",
     "FunctionSignature",
+    "DefaultRewriteDecl",
+    "InitRef",
 ]
 
 
@@ -80,7 +82,13 @@ class DelayedDeclerations:
 
     @property
     def __egg_decls__(self) -> Declarations:
-        return self.__egg_decls_thunk__()
+        try:
+            return self.__egg_decls_thunk__()
+        # 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 = "Error resolving declerations"
+            raise RuntimeError(msg) from err
 
 
 @runtime_checkable
@@ -113,6 +121,12 @@ class Declarations:
     _classes: dict[str, ClassDecl] = field(default_factory=dict)
     _rulesets: dict[str, RulesetDecl | CombinedRulesetDecl] = field(default_factory=lambda: {"": RulesetDecl([])})
 
+    @property
+    def default_ruleset(self) -> RulesetDecl:
+        ruleset = self._rulesets[""]
+        assert isinstance(ruleset, RulesetDecl)
+        return ruleset
+
     @classmethod
     def create(cls, *others: DeclerationsLike) -> Declarations:
         others = upcast_declerations(others)
@@ -127,7 +141,7 @@ class Declarations:
 
     def copy(self) -> Declarations:
         new = Declarations()
-        new |= self
+        self.update_other(new)
         return new
 
     def update(self, *others: DeclerationsLike) -> None:
@@ -154,9 +168,13 @@ class Declarations:
         other._functions |= self._functions
         other._classes |= self._classes
         other._constants |= self._constants
+        # Must combine rulesets bc the empty ruleset might be different, bc DefaultRewriteDecl
+        # is added to functions.
+        combined_default_rules: set[RewriteOrRuleDecl] = {*self.default_ruleset.rules, *other.default_ruleset.rules}
         other._rulesets |= self._rulesets
+        other._rulesets[""] = RulesetDecl(list(combined_default_rules))
 
-    def get_callable_decl(self, ref: CallableRef) -> CallableDecl:
+    def get_callable_decl(self, ref: CallableRef) -> CallableDecl:  # noqa: PLR0911
         match ref:
             case FunctionRef(name):
                 return self._functions[name]
@@ -170,8 +188,29 @@ class Declarations:
                 return self._classes[class_name].class_methods[name]
             case PropertyRef(class_name, property_name):
                 return self._classes[class_name].properties[property_name]
+            case InitRef(class_name):
+                init_fn = self._classes[class_name].init
+                assert init_fn
+                return init_fn
         assert_never(ref)
 
+    def set_function_decl(
+        self, ref: FunctionRef | MethodRef | ClassMethodRef | PropertyRef | InitRef, decl: FunctionDecl
+    ) -> None:
+        match ref:
+            case FunctionRef(name):
+                self._functions[name] = decl
+            case MethodRef(class_name, method_name):
+                self._classes[class_name].methods[method_name] = decl
+            case ClassMethodRef(class_name, name):
+                self._classes[class_name].class_methods[name] = decl
+            case PropertyRef(class_name, property_name):
+                self._classes[class_name].properties[property_name] = decl
+            case InitRef(class_name):
+                self._classes[class_name].init = decl
+            case _:
+                assert_never(ref)
+
     def has_method(self, class_name: str, method_name: str) -> bool | None:
         """
         Returns whether the given class has the given method, or None if we cant find the class.
@@ -183,12 +222,20 @@ class Declarations:
     def get_class_decl(self, name: str) -> ClassDecl:
         return self._classes[name]
 
+    def get_paramaterized_class(self, name: str) -> TypeRefWithVars:
+        """
+        Returns a class reference with type parameters, if the class is paramaterized.
+        """
+        type_vars = self._classes[name].type_vars
+        return TypeRefWithVars(name, tuple(map(ClassTypeVarRef, type_vars)))
+
 
 @dataclass
 class ClassDecl:
     egg_name: str | None = None
     type_vars: tuple[str, ...] = ()
     builtin: bool = False
+    init: FunctionDecl | None = None
     class_methods: dict[str, FunctionDecl] = field(default_factory=dict)
     # These have to be seperate from class_methods so that printing them can be done easily
     class_variables: dict[str, ConstantDecl] = field(default_factory=dict)
@@ -293,6 +340,11 @@ class ClassMethodRef:
     method_name: str
 
 
+@dataclass(frozen=True)
+class InitRef:
+    class_name: str
+
+
 @dataclass(frozen=True)
 class ClassVariableRef:
     class_name: str
@@ -305,7 +357,9 @@ class PropertyRef:
     property_name: str
 
 
-CallableRef: TypeAlias = FunctionRef | ConstantRef | MethodRef | ClassMethodRef | ClassVariableRef | PropertyRef
+CallableRef: TypeAlias = (
+    FunctionRef | ConstantRef | MethodRef | ClassMethodRef | InitRef | ClassVariableRef | PropertyRef
+)
 
 
 ##
@@ -378,7 +432,6 @@ class FunctionSignature:
 @dataclass(frozen=True)
 class FunctionDecl:
     signature: FunctionSignature | SpecialFunctions = field(default_factory=FunctionSignature)
-
     # Egg params
     builtin: bool = False
     egg_name: str | None = None
@@ -458,7 +511,7 @@ class CallDecl:
     bound_tp_params: tuple[JustTypeRef, ...] | None = None
 
     def __post_init__(self) -> None:
-        if self.bound_tp_params and not isinstance(self.callable, ClassMethodRef):
+        if self.bound_tp_params and not isinstance(self.callable, ClassMethodRef | InitRef):
             msg = "Cannot bind type parameters to a non-class method callable."
             raise ValueError(msg)
 
@@ -629,7 +682,13 @@ class RuleDecl:
     name: str | None
 
 
-RewriteOrRuleDecl: TypeAlias = RewriteDecl | BiRewriteDecl | RuleDecl
+@dataclass(frozen=True)
+class DefaultRewriteDecl:
+    ref: CallableRef
+    expr: ExprDecl
+
+
+RewriteOrRuleDecl: TypeAlias = RewriteDecl | BiRewriteDecl | RuleDecl | DefaultRewriteDecl
 
 
 @dataclass(frozen=True)