Merge pull request #140 from oscarbenjamin/pr_update

Reformat due to black changes

Author: oscarbenjamin

Diff for: benchmarks/test_differentiation.py

@@ -4,6 +4,7 @@
 SymPy's and SymEngine's symbolic differentiation.
 
 """
+
 from typing import Callable, TypeVar
 
 import pytest

Diff for: docs/conf.py

@@ -1,4 +1,5 @@
 """Sphinx configuration."""
+
 from datetime import datetime
 
 project = "ProtoSym"

Diff for: noxfile.py

@@ -1,4 +1,5 @@
 """Nox sessions."""
+
 import shutil
 import sys
 from pathlib import Path

Diff for: src/protosym/__main__.py

@@ -1,4 +1,5 @@
 """Command-line interface."""
+
 import sys
 
 

Diff for: src/protosym/core/atom.py

@@ -2,6 +2,7 @@
 
 This module defines the :class:`AtomType` and :class:`Atom` types.
 """
+
 from __future__ import annotations
 
 from typing import TYPE_CHECKING as _TYPE_CHECKING

Diff for: src/protosym/core/differentiate.py

@@ -4,6 +4,7 @@
 level code in the sym module wraps this to make a nicer pattern-matching style
 interface for specifying differentiation rules.
 """
+
 from __future__ import annotations
 
 from dataclasses import dataclass, field
@@ -143,4 +144,4 @@ def chain_rule_forward(
     rust_protosym = None
 
 if rust_protosym is not None:  # pragma: no cover
-    from rust_protosym import DiffProperties, diff_forward  # type:ignore # noqa
+    from rust_protosym import DiffProperties, diff_forward  # type:ignore

Diff for: src/protosym/core/evaluate.py

@@ -1,4 +1,5 @@
 """Define the core evaluation code."""
+
 from __future__ import annotations
 
 from typing import TYPE_CHECKING as _TYPE_CHECKING

Diff for: src/protosym/core/sym.py

@@ -7,6 +7,7 @@
 build a nicer syntax over the lower-level classes that can be inherited for use
 by user-facing classes that derive from :class:`Sym`.
 """
+
 from __future__ import annotations
 
 from typing import Any, Callable, Generic, Sequence, TypeVar, overload
@@ -489,51 +490,53 @@ def __init__(self, name: str):
     def __setitem__(
         self,
         pattern: T_sym,
-        call: WildCall[T_sym, PyOp1[T_val]]
-        | WildCall[T_sym, PyOp2[T_val]]
-        | WildCall[T_sym, PyOpN[T_val]],
-    ) -> None:
-        ...
+        call: (
+            WildCall[T_sym, PyOp1[T_val]]
+            | WildCall[T_sym, PyOp2[T_val]]
+            | WildCall[T_sym, PyOpN[T_val]]
+        ),
+    ) -> None: ...
 
     # e.g. eval_f64[Integer[a]] = f64_from_int
     @overload
     def __setitem__(
         self,
         pattern: SymAtomValue[T_sym, S_val],
         call: WildCall[T_sym, PyFunc1[S_val, T_val]],
-    ) -> None:
-        ...
+    ) -> None: ...
 
     # e.g. eval_repr[AtomRule[a]] = AtomFunc(repr)
     @overload
     def __setitem__(
         self,
         pattern: AtomRuleType[T_sym],
         call: WildCall[T_sym, AtomFunc[T_val]],
-    ) -> None:
-        ...
+    ) -> None: ...
 
     # e.g. eval_repr[HeadRule(a, b)] = HeadOp(...)
     @overload
     def __setitem__(
         self,
         pattern: HeadRuleType[T_sym],
         call: WildCall[T_sym, HeadOp[T_val]],
-    ) -> None:
-        ...
+    ) -> None: ...
 
     def __setitem__(  # noqa [C901]
         self,
-        pattern: T_sym
-        | SymAtomValue[T_sym, S_val]
-        | AtomRuleType[T_sym]
-        | HeadRuleType[T_sym],
-        call: WildCall[T_sym, PyOp1[T_val]]
-        | WildCall[T_sym, PyOp2[T_val]]
-        | WildCall[T_sym, PyOpN[T_val]]
-        | WildCall[T_sym, PyFunc1[S_val, T_val]]
-        | WildCall[T_sym, AtomFunc[T_val]]
-        | WildCall[T_sym, HeadOp[T_val]],
+        pattern: (
+            T_sym
+            | SymAtomValue[T_sym, S_val]
+            | AtomRuleType[T_sym]
+            | HeadRuleType[T_sym]
+        ),
+        call: (
+            WildCall[T_sym, PyOp1[T_val]]
+            | WildCall[T_sym, PyOp2[T_val]]
+            | WildCall[T_sym, PyOpN[T_val]]
+            | WildCall[T_sym, PyFunc1[S_val, T_val]]
+            | WildCall[T_sym, AtomFunc[T_val]]
+            | WildCall[T_sym, HeadOp[T_val]]
+        ),
     ) -> None:
         """Add an evaluation rule."""
         if not isinstance(call, WildCall):

Diff for: src/protosym/core/tree.py

@@ -2,6 +2,7 @@
 
 This module defines classes for representing expressions in top-down tree form.
 """
+
 from __future__ import annotations
 
 from dataclasses import dataclass

Diff for: src/protosym/simplecas/__init__.py

@@ -1,4 +1,5 @@
 """Demonstration of putting together a simple CAS."""
+
 from __future__ import annotations
 
 import protosym.simplecas.functions  # noqa

Diff for: src/protosym/simplecas/exceptions.py

@@ -1,4 +1,5 @@
 """Exception types raised in simplecas."""
+
 from protosym.core.exceptions import ProtoSymError
 
 

Diff for: src/protosym/simplecas/expr.py

@@ -1,4 +1,5 @@
 """The Expr class."""
+
 from __future__ import annotations
 
 from functools import reduce, wraps

Diff for: src/protosym/simplecas/functions.py

@@ -1,4 +1,5 @@
 """Basic functions and operations."""
+
 import math
 
 from protosym.core.sym import (

Diff for: src/protosym/simplecas/lambdification.py

@@ -1,4 +1,5 @@
 """lambdification with LLVM."""
+
 from __future__ import annotations
 
 import ctypes

Diff for: src/protosym/simplecas/matrix.py

@@ -1,4 +1,5 @@
 """Simple Matrix class."""
+
 from __future__ import annotations
 
 from typing import TYPE_CHECKING as _TYPE_CHECKING

Diff for: src/protosym/simplecas/sympy_conversions.py

@@ -3,6 +3,7 @@
 These are defined in their own module so that SymPy will not imported if it is
 not needed.
 """
+
 from __future__ import annotations
 
 from typing import Any

Diff for: tests/core/test_sym.py

@@ -41,19 +41,17 @@ def __call__(self, *args: Expr) -> Expr:
         return Expr(self.rep(*args_rep))
 
 
-def _make_atoms() -> (
-    tuple[
-        SymAtomType[Expr, int],
-        SymAtomType[Expr, str],
-        Expr,
-        Expr,
-        Expr,
-        Expr,
-        Expr,
-        Expr,
-        Expr,
-    ]
-):
+def _make_atoms() -> tuple[
+    SymAtomType[Expr, int],
+    SymAtomType[Expr, str],
+    Expr,
+    Expr,
+    Expr,
+    Expr,
+    Expr,
+    Expr,
+    Expr,
+]:
     """Set up a Sym subclass and create some atoms etc."""
     Integer = Expr.new_atom("Integer", int)
     Function = Expr.new_atom("Function", str)

Diff for: tests/test_main.py

@@ -1,4 +1,5 @@
 """Test cases for the __main__ module."""
+
 from protosym import __main__